V, 17 bytes

òÀ|ló10/dòÓÍd/10

Try it online!

There are two inputs, s and n. s is in the buffer, and n is an argument.

òÀ|l     ò          " As long as the current line (s) is longer than n bytes...

    ó               "   Replace...

     10             "     '10'

       /            "   With...

        d           "     'd'

                    "

          Ó        " Put each character on it's own line

            Í       " Replace (on every line)...

             d      "  'd'

              /     " With...

               10   "  '10'

Hexdump:

00000000: f2c0 7c6c f331 302f 64f2 5cd3 cd64 2f31  ..|l.10/d...d/1

00000010: 30    

Python 3, 71 68 bytes

lambda n,s:[c if c!='x'else 10for c in s.replace('10','x',len(s)-n)]

Try it online!

I was iniitially trying to use str.partition() recursively, but using replace smacked me in the face not too long after. Can anyone improve on this?

Also, here's a TIO link that I used to make the test cases into something more copy/pasteable

Brachylog, 23 bytes

∋~c.{ịℕ&ị≤10&ịṫ?∧}ᵛ&∋~l

Try it online!

The input is a pair [Line, N].

This is my first Brachylog program, so there is probably a lot room for improvement.

It is very slow when the length of the line > 7.

Explanation:

∋~c.{ịℕ&ị≤10&ịṫ?∧}ᵛ&∋~l

                            The input

∋                           contains a string

 ~c                         that is formed by concatenating

   .                        the elements in the output array

   .{           ∧}ᵛ     AND For every element in the output array holds that

     ị  ị    ị                The element converted to an integer

      ℕ                       is a natural number

       & ≤10                  and less than or equal to 10

            & ṫ?              and its string repr is equal to the element (*)

                   &    AND The input

                    ∋       contains an element

                     ~l     that is the length of the output 

(*) ịṫ? checks that there are no leading zeroes. It converts the string to integer and then back to string and compares to the original string.

Ruby, 57 bytes

->n,m{m.sub!"10",?A while m[n];m.chars.map{|c|c.to_i 16}}

Try it online!

This may turn out to be not the golfiest approach, but it looks like a fun idea to temporarily substitute 10 for a hex A, which incidentally is also a high mark (if we consider A-F grading system :))

Haskell, 98 bytes

n!x=[y|y<-s x,y==take n y]!!0

s('1':'0':x)=do y<-s x;[1:0:y,10:y]

s(x:y)=(read[x]:)<$>s y

s _=[]

Try it online or test all!

Explanation

The function s does all possible splits, for example: "1010" becomes [[1,0,1,0],[10,1,0],[1,0,10],[10,10]], note how the longest splits end up at the beginning (because 1:0:y comes before 10:y).

With that in mind, we can take all these values and filter the ys out where y == take n y which keeps also splits that are shorter than required. For example with 4 we leave the list the same [[1,0,1,0],[10,1,0],[1,0,10],[10,10]].

Now we can just get the first element in that list because the inputs will always be valid (eg. 5!"1010" would give [1,0,1,0] too, but we don't need to handle it).

Note: I somehow miscounted.. y==take n y is the same length as length y==n :S

JavaScript (Babel Node),  70 69  59 bytes

Takes input as (n)(line).

n=>s=>(a=s.match(/10|./g)).flatMap(x=>x>9&&!a[--n]?[1,0]:x)

Try it online!

Commented

n => s =>                       // given n and s

  (a = s.match(/10|./g))        // split s into marks; a '1' followed by a '0' is always

                                // interpreted as '10'

  .flatMap(x =>                 // for each mark x:

    x > 9 &&                    //   if x = '10',

    !a[--n] ?                   //   then decrement n; if a[n] is undefined:

      [1, 0]                    //     yield [1, 0]

    :                           //   else:

      x                         //     yield the mark unchanged

  )                             // end of flatMap()

JavaScript (ES6), 64 bytes

Takes input as (n)(line).

n=>g=([...s])=>1/s[n]?g(eval(`[${(s+'').replace('1,0',10)}]`)):s

Try it online!

Commented

n =>                            // main function, taking n

  g = ([...s]) =>               // g = recursive function, taking s

                                //     (which is either a string or an array)

    1 / s[n] ?                  // if s[n] is defined (i.e. we have too many marks):

      g(                        //   do a recursive call to g:

        eval(                   //     build a new array by evaluating ...

          '[' +                 //       ... the string representation of an array made by

            (s + '')            //       coercing s to a string and

            .replace('1,0', 10) //       replacing the first occurrence of '1,0' with 10

          + ']'                 //       with surrounding brackets

        )                       //     end of eval()

      )                         //   end of recursive call

    :                           // else:

      s                         //   return s

Perl 6, 25 bytes

->a,b{b~~/(10|.)**{a}/}

Try it online!

Anonymous code block that takes a number and a string and returns as a Match object.

Explanation:

->a,b{                }  # Anonymous code block taking params a and b

        b~~/           /   # Match using b

            (10|.)           # 10 or a single digit

                  **{a}      # Exactly a times, being greedy

Perl 5 -plF, 39 bytes

$a=<>;$_="@F";s/1 0/10/ while$a-1<y/ //

Try it online!

Clean, 128 bytes

import StdEnv

@=[]

@['10':t]=[u++v\u<-[[10],[1,0]],v<- @t];@[h:t]=[[digitToInt h:v]\v<- @t]

?n l=hd[e\e<- @l|length e==n]

Try it online!

JavaScript, 57 bytes

n=>g=s=>s[n]?g(s.replace(10,`x`)):[...s].map(x=>1/x?x:10)

Try it online