0.0000000000000000001 Notice the pattern in the below sequence:

0.1, 0.01, 0.001, 0.0001, 0.00001 and so on, until reaching 0.{one hundred zeros}1


Then, continued:

0.2, 0.02, 0.002, 0.0002, 0.00002 and so on, until reaching 0.{two hundred zeros}2


Continued:

0.3, 0.03, etc, until 0.{three hundred zeros}3


Continued:

0.4, 0.04, etc, until 0.{four hundred zeros}4


Sped up a bit:

0.10, 0.010, etc.  until 0.{one thousand zeros}10


Sped up some more:

0.100, 0.0100...

You get the idea.

The input your code will receive is an integer, the number of terms, and the output is that many number of terms of the sequence. 

Input and output formats are unrestricted, and separators are not required.

Trailing zeros are necessary.

Standard loopholes apply.



The outputs of some nth terms are given below:

nth term -&gt; number
-------------------
1        -&gt; 0.1
102      -&gt; 0.2
303      -&gt; 0.3
604      -&gt; 0.4
1005     -&gt; 0.5 
1506     -&gt; 0.6
2107     -&gt; 0.7
2808     -&gt; 0.8
3609     -&gt; 0.9
4510     -&gt; 0.10
05AB1E, 23 bytes

Online compiler can't show all terms for high N but it works fine offline.

Lvy2°*&gt;F„0.0N×yJ,¼¾¹Qiq


Explanation

                          # implicit input X
Lv                        # for each y in range [1 .. X]
  y2°*&gt;F                  # for each N in range [0 .. y*100+1)
        „0.               # push the string "0."
           0N×            # push 0 repeated N times
              y           # push current y
               J,         # join and print
                 ¼¾¹Qiq   # quit the program after X terms printed


Try it online!