How to get every lines between nth and (n+1)th match of grep in text file

This might be what you want, using any awk:

$ awk '/^Success$/{c++; next} c==2' file
Somebody
Anybody
Someone

or using GNU awk for multi-char RS:

$ awk -v RS='(^|\n)Success(\n|$)' 'NR==3' file
Somebody
Anybody
Someone

The above assumes you want empty lines printed, if not then either of these might be what you want:

$ awk '/^Success$/{c++; next} c==2 && NF' file
Somebody
Anybody
Someone

$ awk -v RS='(^|\n+)Success(\n+|$)' 'NR==3' file
Somebody
Anybody
Someone

depending on your definition of "empty" and whether you want intermediate empty lines handled the same way as beginning/ending empty lines.

Use a counter in AWK:

awk '/Success/ { ++a }  !/Success/ && a==2'

Here, we increment variable a whenever we see Success. For lines that don't match Success, then if a is exactly 2, then we print the line (AWK's default action).

Here's a perl one, just for fun:

$ perl -ne '$l++ && next if /Success/; print if $l==2' file 
Somebody
Anybody
Someone

It's the same idea as the awk approaches already provided: one each time we find Success, increment a counter by one, but also skip to the next line. Then, print if that number is exactly 2.

If you value brevity over clarity, you can shave a few bytes off with:

perl -ne '$l++&&next if/Success/;print if$l==2' file 

And if you value clarity over brevity, you can expand it to:

perl -e '
while(my $line = <STDIN>){
 if ($line =~ /Success/){
   $counter++;
   next
 }
 if ($counter == 2){
   print "$line"
 }
}' < file 

Sed command can deal with this very easily. With -z flag the list turns into a null separated text items. Now remove the first n-1 occurrences of Success and pipe the result to another sed to print the intended block.

I have used a modified/longer input for better demonstration. To print the block from the third until the forth occurrence of Success.

$ cat  input_file
Success
Something
Anything
Success
Somebody
Anybody
Success
Someone
TEXT1
TEXT2
TEXT3

Success

$ sed -z '-es/Success//'{2..1} input_file| sed -n '/Success/,/Success/p'
Success
Someone
TEXT1
TEXT2
TEXT3

Success

Modify {2..1} to suit your purpose. For example to print from 4th occurrence use {3..1} etc.

With perl:

perl -nse '
  if (/$regex/) {
    $n++
  } elsif ($n >= $start) {
    print
  }
  exit if $n >= $stop' -- -regex=Success -start=2 -stop=3 < file

If lines may have more than one occurrence of the regex:

perl -nse '
  if ($matches = /$regex/g) {
    $n += $matches
  } elsif ($n >= $start) {
    print
  }
  exit if $n >= $stop;' -- -regex=Success -start=2 -stop=3 < file

Append && /\S/ to $n >= $start to skip printing the lines than contain no non-whitespace character.

If the pattern behaves like a separator, we can run something along the lines of:

perl -gne 'print [split(/Success/)]->[2]'  file

Here is a shell version, also just for fun:

Notice that to keep it concise there is no effort being made to validate the arguments like in a production-grade script. Call the script like:

$ ~/script.sh "searchtext" n < /path/to/input

or

$ <process-with-output> | ~/script.sh "searchtext" n

where "searchtext" is the content of the search pattern and "n" is an integer with the number of occurrences of the searchtext at which the output should start.

The logic is quite the same as in the AWK and Perl answers but after the n+1th occurrence the reading of the file is stopped altogether. This might make a difference with very long input files combined with low values of "x".

#! /bin/ksh -
typeset    chSign="$1"
typeset -i iStart=$2
typeset    chLine=""

while IFS= read -r chLine || [ -n "$chLine" ]; do
     if [ "$chLine" = "$chSign" ] ; then
          if (( iStart )) ; then
               (( iStart -= 1 ))
               continue
          else
               break
          fi
     else
          if ! (( iStart )) ; then
               print -r - "$chLine"
          fi
     fi
done

exit 0

Using Raku (formerly known as Perl_6)

~$ raku -ne 'BEGIN my $l; $l++ && next if /Success/; .put if $l==2;'  file

#OR:

~$ raku -ne 'BEGIN my ($l,$n)=(0,0); /Success/ 
               ?? ($l++ and $n=1) 
               !! (.put if $l==2 and $n==1);'  file

Here's an answer written in Raku that is inspired by the excellent Perl answer already posted by @terdon. (Note the Sample Input has been modified slightly such that only the word "Success" is capitalized). The first answer above mimics @terdon's answer, while the second answer used Raku's shorthand Test ?? True !! False operator (similar to if/else). Since Raku understands chained comparisons, the .put clause can actually be written .put if 2 <= $l < 3:

Sample Input:

unsuccessful
Success
something
anything
Success
somebody
anybody
someone

Success
again

Sample Output:

somebody
anybody
someone 
 

Pushing matches onto an array, then retrieving by index:

~$ raku -ne 'BEGIN my ($i,$j,$n) = (0,0,0); state @a;  
                 if /Success/ { @a[$i++;0] = $_; $j=0; $n=1 } 
                 else { @a[$i-1;++$j] = $_ if $n == 1 };
             END .[1..*].put for @a[1];'  file

Here's another way to do it using an Array-of-Arrays (i.e. a 2D-array). Basically when Success is encountered that sets the n=1 flag and lines are pushed onto the @a array in the $i++th position. The line containing the word Success is always pushed onto the array at the 0th position of the second (i.e. $jth)-dimension, and the else block ensures that successive lines accumulate there (at the ++$jth position per Success encountered). The END block sets the return. If the END block is given no slice (indexing) parameters, everything is returned:

Sample Output ( END .put for @a;^* ):

Success something anything
Success somebody anybody someone 
Success again

To return the second array element, that's just @a[1]. To return the second array element minus the match (Success), that's just .[1..*].put for @a[1]. The OP can adjust the range as required, basically .[1..*].put for @a[ ($x..^($x+$y)) - 1 ], where $x is the 1-indexed first array element that the OP wants returned, and this extends for $y array elements (note: ^ here says to return up-to-but-not-including the last range element):

Start return at 2nd match ($x=2) and continue for 2 matches ($y=2):

Sample Output (END .[1..*].put for @a[ (2..^(2+2)) - 1 ];):

somebody anybody someone 
again

_{^* Change .put to .join("\n").put to break-up return into individual lines.}

(Rosetta Code 2D-array example)
https://docs.raku.org
https://raku.org