Replace new lines with spaces using awk

Assuming that the lines are ordered in the manner that you show in the question, then the paste command can do that:

$ paste - - < input_file
A1_R1.fastq.gz  A1_R2.fastq.gz
A2_R1.fastq.gz  A2_R2.fastq.gz
A3_R1.fastq.gz  A3_R2.fastq.gz

If you want the columns to be separated by anything other than the default TAB then use the -d option of paste. For a simple space:

$ paste -d ' ' - -  <input_file

For the input you show where all the paired lines are next to each other all you need with any awk is:

$ awk '{ORS=(NR%2 ? "\t" : RS)} 1' file
A1_R1.fastq.gz  A1_R2.fastq.gz
A2_R1.fastq.gz  A2_R2.fastq.gz
A3_R1.fastq.gz  A3_R2.fastq.gz

or if they aren't paired already:

$ shuf file > file1
$ cat file1
A3_R2.fastq.gz
A2_R2.fastq.gz
A1_R1.fastq.gz
A3_R1.fastq.gz
A1_R2.fastq.gz
A2_R1.fastq.gz

and so need to be paired then if you don't mind adding a call to sort:

$ awk '{ORS=(NR%2 ? "\t" : RS)} 1' <(sort file1)
A1_R1.fastq.gz  A1_R2.fastq.gz
A2_R1.fastq.gz  A2_R2.fastq.gz
A3_R1.fastq.gz  A3_R2.fastq.gz

or to pair them within awk:

$ awk -F'_' -v OFS='\t' '$1 in a{print a[$1], $0; next} {a[$1]=$0}' file1
A3_R2.fastq.gz  A3_R1.fastq.gz
A1_R1.fastq.gz  A1_R2.fastq.gz
A2_R2.fastq.gz  A2_R1.fastq.gz

Note in that last script that the R2 field is output before it's R1 partner in some cases. If that's an issue then you can order them when printing:

$ awk -F'_' -v OFS='\t' '
    $1 in a { print (a[$1] < $0 ? a[$1] OFS $0 : $0 OFS a[$1]); next }
    { a[$1] = $0 }
' file1
A3_R1.fastq.gz  A3_R2.fastq.gz
A1_R1.fastq.gz  A1_R2.fastq.gz
A2_R1.fastq.gz  A2_R2.fastq.gz

If your input file is actually many millions of lines long then adding delete a[$1]; before the next would speed up execution time in most cases, probably not worthwhile if it's just a few thousand (trading off the overhead of calling delete a[$1] for every pair vs the overhead of having a large hash table a[]).

If you need the output lines also sorted then you'd need to use GNU awk for PROCINFO["sorted_in"]:

$ awk '{a[$0]} END{PROCINFO["sorted_in"]="@ind_str_asc"; for (i in a) printf "%s%s", i, (++n % 2 ? "\t" : RS) }' file1
A1_R1.fastq.gz  A1_R2.fastq.gz
A2_R1.fastq.gz  A2_R2.fastq.gz
A3_R1.fastq.gz  A3_R2.fastq.gz

but, just like the solution that uses sort, that wouldn't produce the presumably expected order when the numbers in the input can be multiple digits because, for example, A11 would sort alphabetically before A2 - you'd need to split each string up into separate alphabetic and numeric parts and sort each separately or normalize them to always have the same number oc alphabetic and numeric characters in each position, e.g. map A1_R1 into 000A0001_000R0001 or similar before sorting.

Using Raku (formerly known as Perl_6)

If it's always paired reads, and they're always in the correct order:

~$ raku -e '.put for lines.rotor(2);'  file 

If it's always paired reads, but filenames are out-of-order:

~$ raku -e '.put for lines.sort.rotor(2);'  file 

Raku is a programming language in the Perl family. Similar to the excellent awk answer by @EdMorton, if you have to sort the filenames the resultant order will be alphabetic.

https://docs.raku.org/routine/lines
https://docs.raku.org/routine/rotor
https://raku.org

If sometimes files are missing, regardless of filename order:

~$ raku -ne 'BEGIN my %hash;     \  
             %hash.append: .match(/^ (<-[_]>+) _ /).[0]  =>  $_;   \
             END for %hash.sort { .values.put };'   file

#OR

~$ raku -ne 'BEGIN my %hash;     \ 
             %hash.append: m/^ (<-[_]>+) _ /.[0]  =>  $_;    \
             END for %hash.sort { .values.put };'   file 

This second approach is if the input data is less-than-pristine (missing filenames, etc.). Like Perl itself, Raku has an awk-like command-line mode invoked with the -ne ("non-autoprinting linewise") flags. Above, we BEGIN by declaring a %hash. In the body of this "one-liner" each line is .matched on (here .match is short for $_.match meaning to call the function on $_, the topic variable which holds the line text).

The .match (or m/ … /) routine/operator looks for ^ beginning-of-line followed by <-[_]>+ one-or-more of any-character-but _ underscore (i.e. a custom negative character class), followed by _ underscore itself. (FYI, a custom positive character class looks like so: <+[ … ]>). Parentheses capture the leading non-underscore text into $0 or more simply .[0].

Each line is thus deciphered into .[0] as key with $_ (the whole line) as value. The => is used to create a key/value pair. Hash data structures maintain unique keys, so every time the same key is encountered, the new value simply gets appended. At the END of reading lines, we sort the keys, and output the .values per key.

https://course.raku.org/essentials/associatives/hashes/
https://docs.raku.org/language/hashmap
https://raku.org

Sample Input:

A1_R1.fastq.gz
A1_R2.fastq.gz
A2_R1.fastq.gz
A2_R2.fastq.gz
A3_R1.fastq.gz
A3_R2.fastq.gz

Sample Output (either approach):

A1_R1.fastq.gz A1_R2.fastq.gz
A2_R1.fastq.gz A2_R2.fastq.gz
A3_R1.fastq.gz A3_R2.fastq.gz

I would probably start out with the simplest approach:

$ fmt -w30 < files.csv | tr ' ' '\t'
A1_R1.fastq.gz  A1_R2.fastq.gz
A2_R1.fastq.gz  A2_R2.fastq.gz
A3_R1.fastq.gz  A3_R2.fastq.gz

But if your heart is set on using awk, that's straightforward:

$ sort  < files.csv |
  awk 'NR % 2 == 0 {print prev"\t"$0}   {prev = $0}'
A1_R1.fastq.gz  A1_R2.fastq.gz
A2_R1.fastq.gz  A2_R2.fastq.gz
A3_R1.fastq.gz  A3_R2.fastq.gz

We're looking at low bit of NumberofRecord to trigger on every other line. You could always substitute a pattern match if you feel that's clearer.

I'm a fan of sed, and it can join adjacent pairs of lines pretty easily:

sed 'N; s/\n/'$'\t''/' < input > output

The $'\t' in the middle of that is a bash-ism conveying a single tab character, not directly related to sed. In practice, I would probably use a literal tab character instead, but that does not come across clearly in this medium: sed 'N; s/\n/ /' < input > output

Explanation:

• sed starts by reading the first line
• the N instructs sed to read the next line of input and append it to the current one, separated by a newline.
• the s command replaces the newline with a tab.
• there being no more commands, the result of the previous steps is written, then sed reads the next line and cycles back
• sed terminates when it exhausts its input.