Replace Nth line after match

Question

let's say, I have this file with five hundred lines of text.

one
two
three
four
five
six
seven
eight
nine
ten
.
.
.
five-hundred

If I wanted to replace the fifth line after match with some string, I would just do this:

sed '/two/{n;n;n;n;n;s/.*/MODIFIED/}' inputfile

output:

one
two
three
four
five
six
MODIFIED
eight
nine
ten
.
.
.
five-hundred

But what if I want to replace the 60th line after match? I don't want to write 'n' sixty times.

I tried playing around with x, h/H, g/G, and ranges, but I can't still get my desired output.

Answer 1

Workaround with awk:

awk '/two/{ n=NR+5 } NR==n{ sub(/.*/, "MODIFIED") }1' file

or if you want to replace the line

awk '/two/{ n=NR+5 } NR==n{ $0="MODIFIED" }1' file

Answer 2

For this kind of tasks, you may have to consider what to do if the search pattern occurs again before the offset.

awk -v offset=60 '
    /two/ {x[NR + offset]}
  NR in x {delete x[NR]; $0 = "MODIFIED"}
          {print}'

Would make sure a line is replaced whenever the line 60 rows above contained two.

Answer 3

/two/{
    :loop
    N
    /\(\(.*\n\)\{5\}\).*/{
        s//\1Modified/
        b
    }
    b loop
}

Save that in x.sed and execute it as

sed -f x.sed file

or use the one-liner for GNU Sed:

sed '/two/{:a;N;/\(\(.*\n\)\{5\}\).*/{s//\1Modified/;b;};ba;}' file

Line by line analysis:

• 1-2: When the match is found, start a loop. In this loop,
  • 3: Add a line to pattern space with the N command.
  • 4: If there are 5 newline characters — the basic regex is \(.*\n\)\{5\} —, put that in a capture group, leave the last line (.*) uncaptured and
    • 5: Substitute the whole pattern space^* with the capture group followed by the Modified line.
    • 6: Break the loop.
  • 8: Else loop again.

^*An empty regex slot is equivalent to the previously used regex, so that 5th line is equivalent to s/\(\(.*\n\)\{5\}\).*/\1Modified/.

---

Less esoteric is to use Awk:

awk '{c--};/two/{c=5};c==0{$0="Modified"};{print}' file

That starts by decrementing a counter, and because, as all variables, c is initially zero, it only becomes positive if a match is found.

An even more explicit approach would be

awk 'BEGIN{c=-1};/two/{c=5};c==0{$0="Modified"};{print};c>=0{c=c-1}' file

Useful Sed resources:

• Working with multiple lines.
• Flow control for :loop and b commands.
• Back-references for \1.
• The POSIX specification.

Answer 4

A sed (but only GNU sed) solution without loops and using simple ranges is:

sed '/^two$/,+5{/^two$/,+4{b};s/.*/& hello/}'

The only thing to adjust is the match regexps and the +5 and +4 counters.

For 100 lines after the match:

sed '/two/,+100{/two/,+99{b};s/.*/& Modified/}'

Maybe this could clarify how it works:

$ seq 10 | sed '/4/,+3{/4/,+2{s/.*/&changed/;b};s/.*/& Modified.../}'
1
2
3
4changed
5changed
6changed
7 Modified...
8
9
10

Answer 5

Doing a full-line string match and assuming such a match cannot re-occur within the 5 line range, using any awk in any shell on every Unix box:

$ awk 'c&&!--c{$0="MODIFIED"} $0=="two"{c=5} 1' file
one
two
three
four
five
six
MODIFIED
eight
nine
ten
.
.
.
five-hundred

See https://stackoverflow.com/questions/17908555/printing-with-sed-or-awk-a-line-following-a-matching-pattern/17914105#17914105.

Answer 6

If you're editing a file, use a proper editor instead of a stream editor to edit in-place. sed is for when you need streaming capabilities.

In this case, eds ranges and commands are stronger that POSIX seds:

printf '%s\n' 'g/two/+5s/.*/MODIFIED/' wq | ed -s file

And it's easy to spot/change the 5 to, say, 60.

(You can make this a source for a stream if you change wq to %p q, two separate arguments; you don't have to print the whole file, though. You can also write to a different file with 'w otherfile' q, again, two separate arguments.)

Answer 7

Using GNU sed in extended regex -E we setup a 59 newlines pattern space and then keep shifting out from the top till we hit the pattern line. At that point the Target line is the last line in the pattern space.

sed -Ee ':top
  1,59{
    $q;N;b top
  }
  $!N
  /^[^\n]*two/s/[^\n]*$/MODIFIED/
  P;D
' file

Note:

• Change the offset from 59 to whatever required.
• Change the search pattern from two to whatever desired keeping in mind the rules for writing a regex
• with minor tweaks it can be made POSIX sed compliant.

Answer 8

Compact, but perhaps not very obvious solution which should work with any sed flavour and doesn't require looping:

sed -e 'H;/^two$/h;x;/^two\(\n.*\)\{5\}/{s//MODIFIED/;x;}' -e x

Idea: Collect lines in in hold space, beginning with the matching line. If there are n newlines in the hold space, we just added the line to be replaced, so we replace the entire hold space and switch spaces.

In detail:

• H will append any line to the hold space
• /^two$/h will copy the line with the matching pattern to the hold space, overriding all lines we collected before and making sure, the hold space starts with the given pattern one we did pass it
• x exchanges both buffers so we can deal with what we collected in the hold space. Note that we will change buffers back at the end of the script
• /^two\(\n.*\)\{5\}/ is a pattern starting with the trigger line and at least 5 more lines (replace 5 by your desired value). So this pattern will match as soon as we appended five lines after the matching one. Heureka! What to do now? We want to print the replacement AND we need to destroy the hold space so it will not fit again unless another trigger line is found. We can do both things at the same time by replacing the whole stuff by the replacement:
• s//MODIFIED/ replaces our whole hold space (which is in the pattern space since the x command) with the replacement. Leaving out the first pattern of the s command makes it use the last pattern.
• Now another x changes buffers in case we did the replacement, so changing back buffers in the last step will bring our replacement to the pattern space again to get printed. The new hold space will contain the removed line then, not triggering the match in future unless it has been two again

Answer 9

awk -v l=60 '$0~/two/ && !s {s=1} s && ++s == l {$0 = "MODIFIED"; s=0}1'

Looking for a match (only if not found yet) and when find it set a start position, then increment it until a limit. When the limit is reached do the replacement and set again the start position to 0.