You are kinda Replacable to Me You are provided with a non-empty array \$A\$ of integers, all greater than 0. But what good is an array if the elements do not sum up to the number \$N\$ (also provided as input)...
So to change that, you can pick any integer of your choice present in the array and replace any of its digits with a different digit between 0-9 of your choice. What is the minimum number of digits that you should replace so that the sum of the elements becomes \$N\$?
Note that after replacing the digits, some of the numbers may contain leading zeroes, which is fine. For example: you can change \$123\$ to \$023\$, or even \$000\$ if you want to. However, the input will not contain any leading zeroes and you cannot assume any before the input number.
Example
Consider the array \$A=[195, 95]\$ and \$N = 380\$. You can do the following replacements:

195 -&gt; 185
185 -&gt; 181
181 -&gt; 281
95  -&gt; 99

So the new array is \$A=[281,99]\$ with a sum of \$380\$ in 4 steps. However, this is not minimal and you can do it in even fewer steps:

195 -&gt; 295
95 -&gt; 85

So we got our desired sum in 2 steps. There is no way to get a sum of \$380\$ in less than 2 steps so the answer for \$A=[195, 95]\$ and \$N = 380\$ will be \$2\$.
More examples
  A, N -&gt; Answer
[195, 95], 380 -&gt; 2
[100, 201], 0 -&gt; 3
[32, 64], 96 -&gt; 0
[7, 1, 1], 19 -&gt; 2
[100, 37], 207 -&gt; 1
[215], 25 -&gt; 2
[123, 456], 1998 -&gt; 6 

Rules

Standard loopholes are forbidden.
You do not need to handle inputs for which answer does not exist.
This is code-golf, so the shortest code, in bytes, wins.
Haskell, 95… 93 bytes

a#n|s&lt;-show=minimum[sum[1|(x,y)&lt;-s a`zip`s b,x/=y]|b&lt;-mapM(mapM(:s(56^7)))a,n==sum(read&lt;$&gt;b)]

Try it online!
The relevant function is (#), which takes as input the array a and the integer n and returns the minimum number of moves. Elements of a are represented as strings of digits.
How?
Standard bruteforce, we try all the possible substitutions and return the minimum number of changes. The only things I'm vaguely proud of are the show tricks I've found while working on this answer.

First of all, mapM(:show(56^7)) is shorter than mapM(\_-&gt;['0'..'9']) for enumerating all the possible digits substitutions of a single number. We save 3 bytes and we gain an exponentially slower solution.
Moreover, using show a`zip`show b instead of zip(a&gt;&gt;=id)$b&gt;&gt;=id saves another byte.
With the two previous tricks, we use the show function often enough that defining an alias for it saves an additional byte.