Olympic Rings Sequence
Retina, 70 68 62 bytes

.+
10**
.
$.&gt;`
~(`.+
6*$+*
)`.(.+)
L`.{$.1}
%,-6`.

,2,9`.
*
_


Try it online!

Explanation

Let's call the input n, and we'll use 3 as an example.

.+
10**


The 10** is short for 10*$&amp;*_ which replaces the input with a string of 10n underscores.

.
$.&gt;`


Now we replace each underscore with the length of the string up to and including that underscore. So this just results in the number from 1 to 10n all concatenated together (10n is always enough to fill up two lines of the required length).

~(`.+
6*$+*


Eval! This and the next stage will generate the source code of another program, which is then run against that string of concatenated integers.

To generate that program, this stage first replaces the integers with a string of 6n underscores ($+ refers to the program's original input).

)`.(.+)
L`.{$.1}


Then replace those underscores with L`.{…}, where … is 6n-1 (the length of the lines we're looking at). So we've generated a regex, whose quantifier depends on the original input.

When this program gets eval'ed it matches chunks of length 6n-1, of which there will be at least two. For our example input 3, we end up with:

12345678910111213
14151617181920212
22324252627282930


Now we just need to extract the relevant digits.

%,-6`.



First, on each line (%) we remove all but the last five digits (,-6). That gives us

11213
20212
82930


Finally:

,2,9`.
*


We expand every other digit (2) in the first ten (9, this is 0-based) in unary. Those happen to be those in the Olympic Rings positions.

_


And we count the number of resulting underscores, to sum them and convert the result to decimal.