sed or awk: delete n lines following a pattern

Question

How would I mix patterns and numeric ranges in sed (or any similar tool - awk for example)? What I want to do is match certain lines in a file, and delete the next n lines before proceeding, and I want to do that as part of a pipeline.

Answer 1

I'll have a go at this.

To delete 5 lines after a pattern (including the line with the pattern):

sed -e '/pattern/,+5d' file.txt

To delete 5 lines after a pattern (excluding the line with the pattern):

sed -e '/pattern/{n;N;N;N;N;d}' file.txt

Answer 2

Without GNU extensions (e.g. on macOS):

To delete 5 lines after a pattern (including the line with the pattern)

 sed -e '/pattern/{N;N;N;N;d;}' file.txt

Add -i '' to edit in-place.

Answer 3

Simple awk solutions:

Assume that the regular expression to use for finding matching lines is stored in shell variable $regex, and the count of lines to skip in $count.

If the matching line should also be skipped ($count + 1 lines are skipped):

... | awk -v regex="$regex" -v count="$count" \
  '$0 ~ regex { skip=count; next } --skip >= 0 { next } 1'

If the matching line should not be skipped ($count lines after the match are skipped):

... | awk -v regex="$regex" -v count="$count" \
  '$0 ~ regex { skip=count; print; next } --skip >= 0 { next } 1'

Explanation:

• -v regex="$regex" -v count="$count" defines awk variables based on shell variables of the same name.
• $0 ~ regex matches the line of interest
  • { skip=count; next } initializes the skip count and proceeds to the next line, effectively skipping the matching line; in the 2nd solution, the print before next ensures that it is not skipped.
  • --skip >= 0 decrements the skip count and takes action if it is (still) >= 0, implying that the line at hand should be skipped.
  • { next } proceeds to the next line, effectively skipping the current line
• 1 is a commonly used shorthand for { print }; that is, the current line is simply printed
  • Only non-matching and non-skipped lines reach this command.
  • ^{The reason that 1 is equivalent to { print } is that 1 is interpreted as a Boolean pattern that by definition always evaluates to true, which means that its associated action (block) is unconditionally executed. Since there is no associated action in this case, awk defaults to printing the line.}

Answer 4

Using Perl

$ cat delete_5lines.txt
1
2
3
4
5 hello
6
7
8
9
10
11 hai
$ perl -ne ' BEGIN{$y=1} $y=$.  if /hello/ ; print if $y==1 or $.-$y > 5 ' delete_5lines.txt
1
2
3
4
11 hai
$

Answer 5

This might work for you:

cat <<! >pattern_number.txt
> 5 3
> 10 1
> 15 5
> !
sed 's|\(\S*\) \(\S*\)|/\1/,+\2{//!d}|' pattern_number.txt |
sed -f - <(seq 21)
1 
2
3
4
5
9
10
12
13
14
15
21

Answer 6

This solution allows you to pass "n" as a parameter and it will read your patterns from a file:

awk -v n=5 '
    NR == FNR {pattern[$0]; next}
    {
        for (patt in pattern) {
            if ($0 ~ patt) {
                print # remove if you want to exclude a matched line
                for (i=0; i<n; i++) getline
                next
            }
        }
        print
    }
' file.with.patterns -

The file named "-" means stdin for awk, so this is suitable for your pipeline

Answer 7

Patterns may show up within the next 5 lines, so a straight-up delete would inadvertently skip past criteria matches that would extend the boundary of "next 5 lines". Using awk, just set __ to # of lines skipped, and FS to the matching criteria's pattern (i.e. properly-escaped ERE regex).

By utilizing FS, checking whether pattern has matched or not is straight up NF > 1. Otherwise, every line would be matched twice - first by FS to split the input row into unnecessary fields, then once more by the desired pattern itself.

jot 30 | 

---

mawk '(_ < NR) * (NF < 2 || _ = NR + __)' FS='(.1|9)$' __=5

---

1
2
3
4
5
6
7
8
9  <—  9 bypassed 10-14, and 11 bypassed 12-16
17
18
19 <— 19 bypassed 20-24, and 21 bypassed 22-26
27 
28
29 <— 29 bypassed 30

( Before _ gets explicitly assigned, depending on context, it's either empty string "" or numeric 0 , so short of fudging NR itself, all lines prior to the 1st pattern match would get auto printed, including blank lines. )