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

Python 3, 47 bytes

lambda s,n:[*s.replace(b'1',b'n',len(s)-n)]

Try it online!

Takes the "one line" as a bytestring with raw bytes x00 - x09. If it's not acceptable:

Python 3, 56 bytes

lambda s,n:[x-48for x in s.replace(b'10',b':',len(s)-n)]

Try it online!

Takes "one line" as bytestring.

Brachylog, 23 21 bytes

-2 bytes thanks to Fatalize

h~c.{ịℕ≤10&ịṫ?∧}ᵛ&t~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:

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

h                         The first element in the input

 ~c                       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 it has no leading zeroes (*)

                 &t   AND The second element of the input

                   ~l     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.

V, 17, 12 bytes

ÓòÀGjí1“î…0

Try it online!

I was content with 17 bytes, but than 05AB1E came along with 13, and I couldn't let a challenge go unanswered. :D

Ó                      " Put each character on it's own line

  ò                     " Recursively (repeat until an error happens)...

   ÀG                   "   Go to the "n"th line

     j                  "   Move down a line (this will error if there are exactly "n" lines)

      í                 "   Remove...

       1                "     a '1'

        <0x93>          "     START THE MATCH HERE

              î         "     a newline

               <0x85>   "     END THE MATCH HERE

                   0    "     a '0'

Hexdump:

00000000: 5cd3 f2c0 476a ed31 93ee 8530            ...Gj.1...0

Alternate solution:

ÓòÀGjç1î0/J

Unfortunately, this replaces 10 with 1 0

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, 68 bytes

n!('1':'0':x)|n-2<length x=10:(n-1)!x

n!(s:x)=read[s]:(n-1)!x

n!_=

Try it online!

Greedily take 10s as long as there are more digits than marks remaining.

JavaScript, 57 52 bytes

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

Try It Online

Python 3, 71 68 59 bytes

down another 9 bytes thanks to ovs.

lambda n,s:[int(c,11)for c in s.replace('10','a',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

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

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!

05AB1E, 13 bytes

.œsù.ΔïTÝÃJ¹Q

Try it online!
or as a Test Suite

Explanation

.œ              # partitions of the first input

  sù            # of a length equal to the second input

    .Δ          # find the first partition that returns true when:

      ï         # each element is converted to integer

       TÝÃ      # and only numbers in [0 ... 10] are kept

          J     # then join it together

           ¹Q   # and compare it to the first input for equality

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  59 bytes

Saved 5 bytes thanks to @guest271314

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 ...

          `[${s}]`              //       ... the string representation of s where the

          .replace('1,0', 10)   //       first occurrence of '1,0' is replaced with '10'

        )                       //     end of eval()

      )                         //   end of recursive call

    :                           // else:

      s                         //   return s

Java (OpenJDK 8), 78 bytes

A nice one-liner using the streams API.

(n,l)->l.join(":",l.split("10",l.length()-n+1)).chars().map(i->i-48).toArray()

Try it online!

How it works

(n,l)->                     // Lambda function taking int and string

  l.join(":",               // Join the following array with colons

    l.split("10",           // Split the original string on "10"...

      l.length()-n+1))      // But limit the parts to the difference between the length

                            // and expected length, to only remove  required number of 10s              

  .chars()                  // Convert to an intstream of codepoints

  .map(i->i-48)             // Remove 48 to get the numeric value of each codepoint

  .toArray()                // Return an int array

R, 63 bytes

While the length of the string is larger than n, substitute the next 10 you reach for a ":" (the ASCII character after 9). Then split into numbers by taking the ASCII value of each char in the string.

function(n,x){while(nchar(x)>n)x=sub(10,":",x);utf8ToInt(x)-48}

Try it online!

Red, 91 bytes

func[n s][while[n < length? s][replace s"10""a"]foreach c s[prin[either c =#"a"[10][c]""]]]

Try it online!

Jelly, 18 bytes

Ḍ⁵⁻ƊƝr1ŒpS‘⁼ɗƇḢk⁸Ḍ

Try it online!