[Question]
  [
# Introduction
Every number can be represented as ASCII. For example, \$0\$ comes in ASCII is \$48\$, \$1\$ is \$49\$, and so on. Using this method of translating numbers to other numbers, it is possible to infinitely expand a number, by replacing all its digits with their ASCII values and doing the same for the result. For example, if you started with \$0\$, you would expand to \$48\$, then to \$5256\$, and so on.
# Challenge
* You will be given a single digit and a number as input. You can assume the digit will be in the range \$0-9\$, or \$48-57\$ in ASCII. You can assume the digit will always be of length 1, and will be a string. The number will always be a positive integer, greater than -1. If it is 0, you do not expand at all. Other than that, there are no guarantees about its value. If, and only if your language has no method of input, you may store the input in two variables or in a list.
* You must output the ASCII expansion of the digit if you expand it \$n\$ times, n being the number that was the input. If your language has no method of output, you may store it in a variable.
# Example I/O
* `Digit = 0, N = 3`
`Output = 53505354`
* `Digit = 2, N = 2`
`Output = 5348`
* `Digit = 5, N = 0`
`Output = 5`
# Rules
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer (in bytes) wins!
  
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 28 bytes
```
{($^a,*.ords.join...*)[$^b]}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/WkMlLlFHSy@/KKVYLys/M09PT09LM1olLim29n9xYqVCmoKBjrE1F4RppGMEY5rqGFj/BwA "Perl 6 – Try It Online")
### Explanation:
```
{                          }  # Anonymous codeblock
 (               ...*)[$^b]   # Index into an infinite list
  $^a,                        # Starting from the given number
      *                       # Where each element is
       .ords.join             # The ordinal values joined
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 3 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
FÇJ
```
Takes `N` as first input and the digit as second.
[Try it online](https://tio.run/##yy9OTMpM/f/f7XC71///xlwGAA) or [verify all test cases](https://tio.run/##yy9OTMpM/W/s5umi5Gd7eL9CYl6KQkpmemaJrZK9p4u9ksKjtkkKSvbF/90Ot3v9r9X5b8xlwGUEhAZcpgA).
**Explanation:**
```
F    # Loop the (implicit) first input (N) amount of times
 Ç   #  Convert the characters in the string at the top of the stack to its unicode values
     #  (which will take the second input implicitly in the first iteration)
  J  #  Join these unicode integers together to a single string
     # (after the loop, the result is output implicitly)
```
[Answer]
# [Python 2](https://docs.python.org/2/), 55 bytes
```
f=lambda s,n:f(`ord(s[0])`,n-1)+f(s[1:],n)if n*s else s
```
[Try it online!](https://tio.run/##DcfBCsMgDADQe78i5KRdBurYReiXjEI7aqjgUmkcY1/v9m6vftt@SOidp7K@ntsKShLZLMe5GX242S4kV28v/J@PM4nNDDIqpKIJtH/2XBL4WM8sDdiMWeq7GWs7OqTbgAEpDHhHcj8 "Python 2 – Try It Online")
---
**56 bytes**
```
lambda s,n:eval("''.join(`ord(c)`for c in"*n+" s"+")"*n)
```
[Try it online!](https://tio.run/##DcZBDoIwEAXQPaeY/A0daAzWuCHhJi6oQENNnTalajx99a1e@pY9iqluutVgn/fV0qFl3N42KLTt6RG9qDnmVS08u5hpIS/opAcd6MH/cv3sPmx0HlP2Usipzkt6FcVcMUBfGhho0@AKPfwA "Python 2 – Try It Online")
Generates and evaluates monstrosities like:
```
''.join(`ord(c)`for c in''.join(`ord(c)`for c in''.join(`ord(c)`for c in s)))
```
---
**56 bytes**
```
f=lambda s,n:s*0**n or''.join(`ord(c)`for c in f(s,n-1))
```
[Try it online!](https://tio.run/##DcpBDoMgEEDRvaeYzEYgtEGabky8i1ZLHKMzBDGmp6ds//vxl1dhX0oY9un4LBOclvvTOGMYJLXtcxNiNUpa1KzHIAlmIIag6vfotC73SvsXuj4m4ly7IY5XVlXQoX016NH6Bt9o3R8 "Python 2 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~7~~ 5 bytes
```
ṾOVƊ¡
```
[Try it online!](https://tio.run/##y0rNyan8///hzn3@Yce6Di38//@/wX9jAA "Jelly – Try It Online")
-2 bytes after a friend helped me figure out what's wrong with `O`
For some reason, to run all test cases with a footer, an extra byte is required for the explicit `⁹` nilad: [Try it online!](https://tio.run/##y0rNyan8///hzn3@Yce6HjXuPLTw/@Hlx@Y@aloT@f9/dLSBjnGsTrSRjhGQNNUxiI0FAA "Jelly – Try It Online")
```
Ṿ        Stringify the input
 O       and convert each character to a codepoint,
  V      then concatenate them and eval the result,
   Ɗ¡    repeated a number of times equal to the right argument.
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 7 bytes
```
{ṫạc}ⁱ⁾
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFRu/6htw6Ompoe7Omsfbp3wv/rhztUPdy1Mrn3UuPFR477//6MVog10jGN1oo10jICkqY5BbCwA "Brachylog – Try It Online")
```
{   }ⁱ     Repeat
 ṫ         stringifying,
  ạ        converting to a list of codepoints,
   c       and concatenating
      ⁾    a number of times equal to the last element of the input.
```
[Answer]
# [J](http://jsoftware.com/), ~~14~~ 13 bytes
```
[:,":@u:~"+&3
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/o610lKwcSq3qlLTVjP9rcqUmZ@QrGCukKagbqEM4RiCOEZRjAOKYqv8HAA "J – Try It Online")
### How it works
The "bind" operator `&` is commonly used to bind a constant to a dyad, so that it can be used as a monad. However, [the same form can be used as a dyad](https://code.jsoftware.com/wiki/Vocabulary/ampm#dyadic): `x n&v y` (where `n` is a noun and `v` is a dyadic verb) or `x v&n y` applies monadic `n&v` or `v&n` to `y` **repeatedly `x` times**. Using this feature, we can design the target function like this:
```
x some_constant&some_dyad y
run `some_constant some_dyad y` x times
... or ...
x some_dyad&some_constant y
run `y some_dyad some_constant` x times
```
In this case, there is an obvious choice for the `some_constant`, which is `3` for `3 u: y`.
And here goes the full explanation:
```
[:,":@u:~"+&3
           &   Apply this function x times...
      u:~   3  Convert chars of y to ASCII values (3 u:)
   ":@   "+    Convert each number back to string
[:,            Flatten the array to get a single string
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 30 bytes
```
->s,n{n.times{s=s.bytes*''};s}
```
[Try it online!](https://tio.run/##KypNqvyfZhvzX9euWCevOk@vJDM3tbi62LZYL6myJLVYS1291rq49n9BaUmxQlq0uoG6joJxLBeMawTkGiG4pkCuQex/AA "Ruby – Try It Online")
[Answer]
# C# (.NET Core), ~~174~~ 147 bytes
```
class Z{static void Main(string[] a){for(int n=int.Parse(a[1]);n-->0;){var x="";foreach(char c in a[0])x+=c-0;a[0]=x;}System.Console.Write(a[0]);}}  
```
Big help from Jo King.
[Try it online!](https://tio.run/##FYzBCsIwEAV/ZekpQVIiHkO8eBYED4Klh2WNNlATyIZSKfn2mF4ewzA8YkUxuVppRmZ4bpwxe4Il@hdc0QfBOfnwGUZAub1jEj5kCLZtf8PETuBwHKUJSp21kduCCVbbdaalDmkSNDVD4APgoEe5HiwpbXa2qyn3H2f37S8xcJxd/0g@748tNKXUWnU9/QE "C# (.NET Core) – Try It Online")
# Ungolfed
```
class Z
{
   static void Main(string[] a)
    {
        int n = int.Parse(a[1]);
        for (; n-- > 0;)
        {
            var x = "";
            foreach (char c in a[0])
                x += c - 0; //c-0 gets converted to int, and then the int is 
                                   //automatically converted to a string
            a[0]=x;
        }
        System.Console.Write(a[0]);
    }
}
```
[Answer]
# JavaScript (ES6), ~~43~~ 40 bytes
*Thanks to @tsh for reminding me that I didn't use currying this time :p (-3 bytes)*
Takes input as `(N)(digit)`.
```
n=>g=k=>n--?g(k.replace(/./g,c=>c^48)):k
```
[Try it online!](https://tio.run/##XcpNCsMgEEDhfU8RspqB@kOiEAKamxRkaqRVNCSl1zduWmgXb/W9p3u7g/bH9mK53H1dTc3GBhONzYwtASLf/ZYceRBchCsZSzc1Ic6xUslHSZ6nEmCFEaGXPWInRKdHLVvq8rsMbRm@i5r@WDbWH64n "JavaScript (Node.js) – Try It Online")
### How?
This is a simple recursive function. The only trick in there is `c^48`. Because `c` is a string, we need to coerce it to an integer. We could do `+c+48`, but that would be 1 byte longer. Using a bitwise XOR is safe here, as \$48\$ is \$110000\_2\$ and `c` is less than \$10000\_2\$.
[Answer]
# [Haskell](https://www.haskell.org/), ~~30~~ ~~35~~ 30 bytes
```
(!!).iterate(>>=show.fromEnum)
```
[Try it online!](https://tio.run/##JYy9CsIwGEX3PsXX4JBAWkrFpdBsDp0cHNUhhKQNNmnID@LLG1OdDvdezl14eMp1zYZrC8MA0wUwqX5pBOe1jXAAwx3gZEXy/g2KwA2jDtEjoRj1iPY7T4h25FGp/eMaizdDw2AqesG/KOMI94zrmrQ6Ss@jxIyNYdlerfKbOdtkSM4foVY@h9wI574 "Haskell – Try It Online")
+5 then -5 bytes from Jo King clarifying the rules and then working it into pointfree.
My first Haskell golf so I've probably done something horribly wrong. In addition to having misspelled golf, I tried to import `ord` without putting it in my byte count!
```
    .                             The composition of
     iterate                      infinitely iterating, starting with the argument,
            (>>=             )    concatenating the results of mapping
                show              finding the string representation of
                    .fromEnum     the codepoint of the argument,
(!!)                              with indexing into the resulting infinite list.
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-h`](https://codegolf.meta.stackexchange.com/a/14339/), 5 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
VÆ=mc
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LWg&code=VsY9bWM&input=IjAiCjI)
```
VÆ=mc   V = number of times, U = digit
VÆ      V times do: (Collects each result into an array)
  =mc     Map every digit of U to it's ASCII value, and make that the new U
-h      Take last element
```
[Answer]
# [Perl 5](https://www.perl.org/), 22 bytes
```
eval's/./ord$&/ge;'x<>
```
[Try it online!](https://tio.run/##K0gtyjH9/z@1LDFHvVhfTz@/KEVFTT891Vq9wsbu/38DLmMuIyA05TL4l19QkpmfV/xftwAA "Perl 5 – Try It Online")
[Answer]
# [J](http://jsoftware.com/), 18 bytes
```
([:,3":@u:"0])@[&0
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/NaKtdIyVrBxKrZQMYjUdotUM/mtypSZn5CsYK6QpqBuoQzhGII4RlGMA4piq/wcA "J – Try It Online")
From [the J dictionary](https://www.jsoftware.com/help/dictionary/d630n.htm):
> 
> The phrase x f@[&0 y is equivalent to f^:x y , apply the monad f x times to y.
> 
> 
> 
That is, it's a shortcut for power of `^:` applied as many times as the left arg. Which explains the
```
(  )@[&0
```
part of the code. Now for what's in the parentheses:
`3 u:]` converts to a unicode code point, but unfortunately has infinite rank, and we want to apply it with 0 rank, hence the added `"0`. The code point is a number, and we convert it back to a string with format `":`. Finally, we flatten `,` this list of strings.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~51~~ 49 bytes
 -2 bytes thanks to mazzy
```
param($s,$n),1*$n|%{$s=-join($s|% t*y|%{+$_})};$s
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfmvkmZb/b8gsSgxV0OlWEclT1PHUEslr0a1WqXYVjcrPzMPKFyjqlCiVQkU01aJr9WstVYp/l/LxaWmkqagZKCkYAxhGSkpGEFYpkoKBv8B "PowerShell – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~63~~ 57 bytes
```
f=lambda i,n:n and f(''.join(`ord(c)`for c in i),n-1)or i
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P802JzE3KSVRIVMnzypPITEvRSFNQ11dLys/M08jIb8oRSNZMyEtv0ghWSEzTyFTUydP11ATyM38X1CUmVcCUmygrmOsyQUE/wE "Python 2 – Try It Online")
-6 bytes due to [Jonathan Allan](https://codegolf.stackexchange.com/users/53748/jonathan-allan) noting that the input can be a string.
Takes input as single digit string and an integer number of repetitions.
[Answer]
# [Bracmat](https://github.com/BartJongejan/Bracmat), 63 bytes
```
get':%?a %?n&whl'(!n+-1:~<0:?n&str$vap$((=.asc$!arg).!a):?a)&!a
```
[Try it online!](https://tio.run/##SypKTM5NLPn/Pz21RN1K1T5RQdU@T608I0ddQzFPW9fQqs7GwAooUlxSpFKWWKCioWGrl1icrKKYWJSuqaeYqGlln6ipppj4v6C0BCj430DBGAA "Bracmat – Try It Online")
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), ~~13~~ 9 bytes
-4 bytes thanks to ngn
```
(,/$`i$)/
```
[Try it online!](https://tio.run/##y9bNz/7/P81KQ0dfJSFTRVP/f1q0sbWSgVLsfwA "K (oK) – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 30 bytes
```
(!!).iterate(show.fromEnum=<<)
```
[Try it online!](https://tio.run/##BcFBCoAgEADAr@iSoFASRbc89orqIGElqYka/b5t5tT5Ms4hZ0ItyCkV0haTdDE8n/cr93T7KTxejaNAr20gisRkQyEVmaEF1tfQAetqGIC1K37b7vSRsdli/AE "Haskell – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 9 bytes
```
ＦＮ≔⭆η℅κηη
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z8tv0hBwzOvoLTErzQ3KbVIQ1NTwbG4ODM9TyO4pCgzL903sUAjQ0fBvyglMy8xRyNbU1NHIUPTmisAKFmiAWT9/2/MZfBftywHAA "Charcoal – Try It Online") Link is to verbose version of code. Takes `N` as the first input and the digit as the second input. Explanation:
```
ＦＮ
```
Repeat `N` times...
```
≔⭆η℅κη
```
Map each character to its ordinal and concatenate.
```
η
```
Output the final result.
Sadly `ＦＮ≦℅ηη` doesn't work...
[Answer]
# [Lua](https://www.lua.org/), 55 bytes
```
a,N=...for i=1,N do a=a:gsub('.',('').byte)end
print(a)
```
[Try it online!](https://tio.run/##yylN/P8/UcfPVk9PLy2/SCHT1lDHTyElXyHRNtEqvbg0SUNdT11HQ11dUy@psiRVMzUvhaugKDOvRCNR8////wb/jQE "Lua – Try It Online")
Take input as arguments. Explanation is fairly obvious.
# Alternative solution: [Lua](https://www.lua.org/), 60 bytes
```
a,N=...for i=1,N do a=table.concat{a:byte(1,-1)}end
print(a)
```
[Try it online!](https://tio.run/##yylN/P8/UcfPVk9PLy2/SCHT1lDHTyElXyHRtiQxKSdVLzk/LzmxpDrRKqmyJFXDUEfXULM2NS@Fq6AoM69EI1Hz////Bv@NAQ "Lua – Try It Online")
[Answer]
# [QuadR](https://github.com/abrudz/QuadRS), 8 bytes
Translation of [Nahuel Fouilleul](https://codegolf.stackexchange.com/users/70745/nahuel-fouilleul)'s [solution](https://codegolf.stackexchange.com/a/194746/43319). Thanks to [Veskah](https://codegolf.stackexchange.com/users/78849/veskah) for [pointing it out](https://chat.stackexchange.com/transcript/message/52256724#52256724).
```
.
⎕UCS⍵M
```
[Try it online!](https://tio.run/##KyxNTCn6/1@P61Hf1FDn4Ee9W33//zf4bwwA "QuadR – Try It Online")
`.` replace any character
`⎕UCS` with the Universal Character Set ordinal of the  
`⍵M` Match
This is equivalent to the [Dyalog APL](https://www.dyalog.com/) expression `'.'⎕R{⍕⎕UCS⍵.Match}⍣⎕⊢⍞`. [Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKO94L@6nvqjvqlB1Y96pwLpUOfgR71b9XwTS5Izah/1LgYKPepa9Kh3HkjxfwUwKOAy4DIGAA "APL (Dyalog Unicode) – Try It Online")
[Answer]
# Lua, 67 bytes
```
i=io.read d=i(1)for _=1,i()do
d=d:gsub(".",string.byte)end
print(d)
```
[Try it online!](https://tio.run/##yylN/P8/0zYzX68oNTFFIcU2U8NQMy2/SCHe1lAnU0MzJZ8rxTbFKr24NElDSU9Jp7ikKDMvXS@psiRVMzUvhasAyC3RSNH8/99AwRgA "Lua – Try It Online")
Let `d` be the digit we will transform (always of length 1, so we ask to read 1 character with `io.read(1)`).
If `N > 0`, replace each character by its byte value.
Return the digit.
[Answer]
# [Thunno 2](https://github.com/Thunno/Thunno2), 3 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md)
```
{CJ
```
[Try it online!](https://Not-Thonnu.github.io/run#aGVhZGVyPSZjb2RlPSU3QkNKJmZvb3Rlcj0maW5wdXQ9MyUwQSUyMjAlMjImZmxhZ3M9)
#### Explanation
```
{CJ  # Implicit input
{    # Repeat N times:
 C   #  Get ASCII codes
  J  #  Join into a string
     # Implicit output
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 41 bytes
```
""<>ToString/@ToCharacterCode@#&~Nest~##&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7X0nJxi4kP7ikKDMvXd8hJN85I7EoMbkktcg5PyXVQVmtzi@1uKROWVntfwBQSUm0sq5dmoODcqyavkM1V7WSgZKOca0OkGGkpGMEZpgq6RjUctVy/QcA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 16 bytes
```
{(∊⍕¨∘⎕UCS)⍣⍵⊢⍺}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///v1rjUUfXo96ph1Y86pjxqG9qqHOw5qPexY96tz7qWvSod1ft/7RHbRMe9fYB5Tz9H3U1H1pv/KhtIpAXHOQMJEM8PIP/qxuoK6QpGHOpG4FoIy51UxBtAAA "APL (Dyalog Unicode) – Try It Online")
Left input is a one-digit string, right input is the number of iteration. Returns the string representation of the result.
### How it works
```
{(∊⍕¨∘⎕UCS)⍣⍵⊢⍺}
{              }  Dyadic dfn, ⍺=digit string, ⍵=iteration
             ⊢⍺   Start with ⍺
 (        )⍣⍵     Repeat ⍵ times...
      ⎕UCS        Convert each char to Unicode codepoint
   ⍕¨∘            Convert each number back to string
  ∊               Enlist (flatten) all chars into one string
```
[Answer]
# [PHP](https://php.net/), 58 bytes
```
for([,$a,$b]=$argv;$b--;)$a=strtr($a,range(48,57));echo$a;
```
[Try it online!](https://tio.run/##NY1BCsIwEEX3OUUoWSQwhdJaFGLxIDHItMRmoW1IoiDi2WNa66we/P/@OOvS8eSsI4RFE2KgHVWE5lMVNBp@WEP9xxaqjFoScp29wcFSvokY6EqCvtcqQz8@8xx6j6/L3fjRcDU9bjcNW1GmvMEVMATW624VJOvLUgqGXYg@ep4zj1NWdwdo90JIM9iZoUzLi4VpcZ4KST4pVan5Ag "PHP – Try It Online")
Input digit and number are two command arguments (`$argv`) in same order.
### Comented
```
for(
  [,$a,$b]=$argv;  // $a is input digit and $b is number
  $b--;            // loop $b times
)
  $a=              // set $a to
    strtr(         // strtr in array mode, replaces keys with values
      $a,          // replace in $a itself
      range(48,57) // an array with keys 0...9 and values 48...57
    );
echo$a;            // at the end, output $a
```
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 55 bytes
```
a=>b=>{for(;b-->0;a=a.SelectMany(l=>l-0+""));return a;}
```
[Try it online!](https://tio.run/##ZY5NS8QwEIbv@RVDTwlNSyt4MU0uywqCenAFz9NsqoHuFNLUD0p@e03Xo6cX3meembFzZWe/3S9ku4cjLRcXsB9dZz8wGHmtPUX5Dxkz6A216bVZhylw1VeVaRRqrE9udDY@If3wUZuxasqiEEIFF5dAgCptin1igEDvoIHcF7wgnacLF4rtq/I98Jk0KkcH7Z5lKWBlAH/eOdNs18/uO/JWwm02Ad6Cj@7Rk@PF2iQJa5vuYL1JhQQvd0vCHIPP3mEii5EP3Nev0@nacSF4HhH5UZbY9gs "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), ~~69~~ 60 bytes
```
f=lambda n,i:i and f(''.join(str(ord(c))for c in n),i-1)or n
```
[Try it online!](https://tio.run/##DcfBCoAgDADQXxle2sCC7Bb0MaZIi9rEvPT1q3d79e2HymJWtivee44gnleGKBkKDsN0Kgs@vaG2jImoaIMELCDkeZzpr1htLB0LuuB8ILIP "Python 3 – Try It Online")
[Answer]
# [Red](http://www.red-lang.org), ~~62~~ 57 bytes
```
func[d n][loop n[parse d[any[change p: skip(0 + p/1)]]]d]
```
[Try it online!](https://tio.run/##RccxDoMwDAXQnVN8ZaJiaAB14RhdLQ8RTgAVGSvAwOnTDd72cpTyjUJcpaGkU0cSKNO6bQYlC3mPEAp60TgHnSJswP5brPZoYO/2xczCxfKiBxKcd@ire51D9@zj4Msf "Red – Try It Online")
Explanation:
```
f: func [ d n ] [                  ; a function with 2 parameters
    loop n [                       ; repeat n times
        parse d [                  ; parse the string with the following rules        
            any [                  ; one ore more 
                change p: skip     ; change any string with length 1 (a single digit)
                (0 + p/1)          ; with its representation as a number 48..57 
            ]                       
        ]
    ]
    d                              ; return the altered string
]
```
[Answer]
# [Icon](https://github.com/gtownsend/icon), ~~72~~ 63 bytes
Inspired by @xnor's [Python 2 solution](https://codegolf.stackexchange.com/a/194755/75681)
```
procedure f(d,n)
return(*d*n<1&d)|f(48+!d,n-1)||f(d[2:0],n)
end
```
[Try it online!](https://tio.run/##y0zOz/v/v6AoPzk1pbQoVSFNI0UnT5OrKLWktChPQytFK8/GUC1FsyZNw8RCWxEop2uoWQPkpUQbWRnEgpSm5qUg6c9NzMzT0ORSAILyosySVI00DSUDJR1jTTQxIyUdI3QxUyUdA02IgQA "Icon – Try It Online")
]