[Question]
  [
The powers that be want to be able to quickly convert any number they have into their own number base using any format they would like.
**Input** 
Your program must accept 3 parameters.
1. Number: The string number to be converted
2. InputFormat: the base string the number is currently in
3. OutputFormat: the base string that the number is to be converted to.
**Output**
Your program must convert the `Number` from the old number base `InputFormat` to the new number base `OutputFormat`
**Examples**
```
("1","0123456789","9876543210") = "8"
("985724","9876543210","0123456789ABCDEF") = "37C3"
("FF","0123456789ABCDEF","0123456789") = "255"
("FF","0123456789ABCDEF","01234567") = "377"
("18457184548971248772157", "0123456789","Aa0Bb1Cc2Dd3Ee4Ff5Gg6Hh7Ii8Jj9Kk,Ll.Mm[Nn]Oo@Pp#Qq}Rr{Ss-Tt+Uu=Vv_Ww!Xx%Yy*Zz") = ",sekYFg_fdXb"
```
***Additional***
The new base 77 test is not required props if it works though
1. if your in a language where you have to convert to a number first and are locked within 32Bit you can skip it.
2. as it's an additional test.
All examples were generated by PHP 7.2 with the bcmath extension using the following code (vars mins but code formatted). there will probably be a shorter way this is just the way I came up with for the system I needed to do this with would be nice to see if anyone could come up with a shorter version though.
PHP 7.2 (bcmath - extension) 614 bytes
```
<?php
function f($a, $b, $c)
{
    $d= str_split($b,1);
    $e= str_split($c,1);
    $f= str_split($a,1);
    $g=strlen($b);
    $h=strlen($c);
    $k=strlen($a);
    $r='';
    if ($c== '0123456789')
    {
        $r=0;
        for ($i = 1;$i <= $k; $i++)
            $retval = bcadd($retval, bcmul(array_search($f[$i-1], $d),bcpow($g,$k-$i)));
        return $r;
    }
    if ($b!= '0123456789')
        $l=f($a, $b, '0123456789');
    else
        $l= $a;
    if ($l<strlen($c))
        return $e[$l];
    while($l!= '0')
    {
        $r= $e[bcmod($l,$h)].$r;
        $l= bcdiv($l,$h,0);
    }
    return $r;
}
```
[Try it Online](https://tio.run/##lVLZkppAFH33K3pIp6QjWjSCYCGVzGb2fY9jWU3TCLEHCKBmMuW3mx4ZBCq8hCqWe865y7l0EiT7/eRxEiQdfx3RPIwj4MuQKAC64qaoc9sB4oKeA7I8XWQJD3NZcBjZBcEaBK0Iv0GQilg6AucsEmVKKDhCtIRWR4iUUOp0u8Vn6AMhdRzQVbE21I2RaY276EAV897rVfsY@XEqckLgAGyL18QRLWwAw14PHTVFFss3hAudS4nnyfexIsLrNZdJmpKbRcZISgMZ@jMY9vFcbMpDikuTeCvDpQJXfRgihKrmosY6jUTtAtpVJtyTNhOHQbhT/YmGpCjCeMbqYgBJbTl8Um0U/TMHm0E@L9TbIORM6A9ztO3wTi28x2IVXIEBmg9KG2Vjl3rhpmAVFdUt1nzv9owGsThcEpYUqbIjgrFljgx9qGFVQgPpKr2KJLtTqseWYWp6U1XPPz07v7ictiROp226Ruv/T2pJwZZumHcP3RqbWNMt09SwYUoKaLo8JeqZi8@pduENL5k@9Y2ny9GzwHweWi9@jl@ulFd88Pp69iaav42fvEsevP@1@5Defsz6n/Le57XzZbP4uj359vvh95tHP/5Uc@z/Ag)
**Scoring**
This is code golf; shortest code wins. Standard loopholes apply.
  
[Answer]
# [MATL](https://github.com/lmendo/MATL), 2 bytes
```
Za
```
[Try it online!](https://tio.run/##y00syfn/Pyrx/391Nzd1LnUDQyNjE1MzcwtLRydnF1dkIXUA "MATL – Try It Online")  
[All test cases.](https://tio.run/##y00syfmf8D8q8b9LyH91Q3UudQNDI2MTUzNzC0sgx9LC3MzUxNjI0ADMMTU3MkEXRah3dHJ2cXUDCrm5YRdHMZqQInUA "MATL – Try It Online")
For the [Za lord](https://www.deviantart.com/mommyspike/art/Pizza-or-Death-113693905)!
[Answer]
# [R](https://www.r-project.org/), 124 bytes
```
function(n,s,t,T=L(t),N=(match(!n,!s)-1)%*%L(s)^(L(n):1-1))intToUtf8((!t)[N%/%T^rev(0:log(N,T))%%T+1])
"!"=utf8ToInt
L=nchar
```
[Try it online!](https://tio.run/##Vc7NCoJAFEDhvU@hAwP31kTaf5KLsoRgcDWtIsHESqg7oFdf31zW9uMsTt3f86aMLXVlze5u4vaPlgquLAGpRrEykQZGlUbwybl4gUfKa3ASoBxJDQ1moIEwDAbBitjYCz82AB7jNZVTabK67MAP3/YJqTKIUppxcENHeCJqh9TYM7GjIypeef07AyJJhBJ@MJsvlqv1Zrs/xMfTPwnsvw "R – Try It Online")
Ugh, this was a doozy. I use the typical base conversion tricks for R, but string manipulations in R are still messy!
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 22 bytes
Anonymous infix lambda. Takes `InputFormat` as left argument and `OutputFormat` as right argument, and prompts for `Number` from stdin. Assumes `⎕IO` (**I**ndex **O**rigin) to be `0`, which is default on many systems.
```
{⍵[(≢⍵)⊥⍣¯1⊢(≢⍺)⊥⍺⍳⎕]}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkG/6sf9W6N1njUuQhIaz7qWvqod/Gh9YaPuhZBxHZBxHY96t0M1BNb@z8NqOtRbx/EgK7mQ@uNH7VNBPKCg5yBZIiHZ/B/dQNDI2MTUzNzC0v1NHVLC3MzUxNjI0MDdS51QyBGEkhDUuro5Ozi6gaWNzU3MgEyMOSQlQPl3dzwK4IoAQA "APL (Dyalog Unicode) – Try It Online")
`{`…`}` "dfn"; `⍺` is left argument, `⍵` is right argument  
 (mnemonic: left and right ends of the Greek alphabet)
 `⍵[`…`]` index the output format with the following:
  `⎕` prompt for input
  `⍺⍳` **ɩ**ndices of those characters in the input format
  `(`…`)⊥` evaluate as being in the following base:
   `≢⍺` the length of the input format
  `⊢` yield that (separates `¯1` from `(≢⍺)`)
  `(`…`)⊥⍣¯1` convert to the following base:
  `≢⍺` the length of the output format
[Answer]
## C (gcc), 79 + 46 = 125 bytes
```
char*O;l,n;g(n){n/l&&g(n/l);write(1,O+n%l,1);}
```
This must be compiled with the
```
-Df(s,i,o)=for(n=l=0;n=n*strlen(i)+index(i,s[l])-i,s[++l];);l=strlen(O=o);g(n)
```
flag. (Yes, this is incredibly sketchy, which is why I'm keeping my old answer below.) This defines a macro `f` that outputs the answer to STDOUT.
[Try it online!](https://tio.run/##nZDBSsNAEIbvPkVYaNlpNjSbJk3Csge15poHkB7CmqQL40SyEYXSV3dNi4IFvTiXmR@@bxjGRL0x3ptDM65qhYJUzwmOtMblcp7WCOpttFPLpahDWqCQoE7e0hQ8N5Y4BMebYK6OM8kEi2WySbNtXpRzKIt8m6WbRMYM1IV6eZ0cZ99pdsoiy5P0mv255fbufvdQ/alX1W/01Rn/Vc/oyX@YDpve@WjXcSesGEB3w8hJo44VaVq5acSWuIXQ0lP7zq1wj7iH6NzDEPcKFOovqNYDXL77CQ)
## C (gcc), ~~133~~ 131 bytes
```
char*O;l;g(n){n/l&&g(n/l);write(1,O+n%l,1);}f(s,i,o,n)char*s,*i,*o;{for(n=0,l=strlen(O=o);n=n*strlen(i)+index(i,*s)-i,*++s;);g(n);}
```
[Try it online!](https://tio.run/##nY7BaoNAEIbvfQpZaJjRCXGNRmXx0KT16jMEq@nCZgyupQXx2c1GWmigvXQOw/zwfTNTr091Pc/127H3K2XUCRhH3pjVyk0bg@qj10MDkqqAHw1JVFMLljR1xLhYlnxNfqfGtuuBi5BMYYfeNAxV0aHigv2vrDHQ/Np8guMtrl0PAqtwuammWfPgnY@aAb3xwXPVgpCCRCijbZzs0ix3Ic/SXRJvIxkKVAt1eR8siO/knDxL0ii@Z39uedofnl/KP/Wy/I2@e@O/6g2d5is)
This defines a function `f` that outputs the answer to STDOUT.
```
char*O;           // declare variable to store output charset
l;                // will be set to length of O
g(n){             // helper function to print the result
  n/l&&g(n/l);    // recursively calls itself if there are more digits
  write(1,        // output to stdout...
   O+n%l,1);      // the byte at (n mod output base) in O
}
f(s,i,o,n)        // main function
char*s,*i,*o;{    // declare string inputs
for(n=0,          // initialize n to 0
l=strlen(O=o);    // assign output charset so we don't have to pass it to g
n=n*strlen(i)     // repeatedly multiply n by input base...
+index(i,*s)-i,   // ... add the index of the digit in input charset...
*++s;);           // and move to the next digit until there's none left
g(n);             // call the helper function on the resulting integer
}
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~5~~ 3 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
nVW
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=2.0a0&code=blZX&input=IkZGIgoiMDEyMzQ1Njc4OUFCQ0RFRiIKIjAxMjM0NTY3Ig)
---
## Explanation
```
         :Implicit input of U=Number, V=InputFormat & W=OutputFormat
 nVW     :Convert U from base V to base W
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes
```
ÅβIÅв
```
[Try it online!](https://tio.run/##yy9OTMpM/f//cOu5TZ6HWy9s@v/fzY3LwNDI2MTUzNzC0tHJ2cUVWQAA "05AB1E – Try It Online")
This does *not* work in the legacy version of 05AB1E. It only works on the new version, the Elixir rewrite.
### How it works
```
ÅβIÅв – Full program.
Åβ    – Convert from custom base to decimal.
  I   – Push the third input.
   Åв – Convert from decimal to custom base. 
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 5 bytes
```
⍘⍘ＳＳＳ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMMpsTg1uATITEdmeuYVlJZA2Zo6CihcDL6m9f//0UqWFqbmRiZKOkCGuZmpibGRoQGQY2BoZGxiamZuYeno5Ozi6qYU@1@3LAcA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
  Ｓ     Input the "number"
   Ｓ    Input the input format
 ⍘      Convert to number using that format
    Ｓ   Input the output format
⍘       Convert to string using that format
        Implicitly print
```
The `BaseString` function automatically converts between number and string depending on the type of the first parameter.
[Answer]
# [MATL](https://github.com/lmendo/MATL), 5 bytes
[sundar found the real builtin to do this!](https://codegolf.stackexchange.com/a/170740/67312) Go upvote that answer instead of my dumb one :-(
```
ZAwYA
```
[Try it online!](https://tio.run/##y00syfn/P8qxPNLx/391Nzd1LnUDQyNjE1MzcwtLRydnF1dkIXUA "MATL – Try It Online")
```
          % implicit input N, the number, and S, the digits of the Source base
ZA        % base2dec, convert string N using S as digits into a base 10 integer
w         % swap stack elements, with implicit input T, the digits of the Target base
YA        % dec2base, reverse the ZA operation with digits coming from T instead.
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~132~~ ~~129~~ ~~122~~ 121 bytes
```
lambda n,a,b:g(sum(len(a)**i*a.find(j)for i,j in enumerate(n[::-1])),b)
g=lambda n,c:c[n:n+1]or g(n/len(c),c)+c[n%len(c)]
```
[Try it online!](https://tio.run/##jZDPboMwDMbPzVNEkSolNN1KgAKROGzdeImOQ6CBUYFbQTjs6VnC/qiVdtjFlu3v91n29cO8X0DMdfY2d6ovTwoDV7yUDR2nnnYaqGKe13rqoW7hRM@svgy45WfcAtYw9XpQRlM4Srn1C8Z4yVCT/TpVsjqChI1fWKqh8OgMK8YrtrGD9VdVzEaPZsQZpmhFKfEJJztfBGG0j5PUFmkS76MwEP6OMI5JYuMiTJMoFuG94BZ9ej68vOYLE8SH4AfL879UdzsdIqLov8T3CpsRQ8h9yF3EBz1OnXGfWg6UaHUdWjC4pp5rsPkT "Python 2 – Try It Online")
An anonymous function (thanks, [Erik the Outgolfer](https://codegolf.stackexchange.com/users/41024/erik-the-outgolfer)!) which converts the original number to a base 10 integer, then passes the integer and the new base string to function g(), which recursively converts to the new base. Now passes length of the OutputFormat as a parameter to g().
Updated g() for a lower bytecount. (thanks, [Dennis](https://codegolf.stackexchange.com/users/12012/dennis)!)
Replaced index() with find(). (thanks, [Mr. Xcoder](https://codegolf.stackexchange.com/users/59487/mr-xcoder)!)
## Ungolfed Explanation:
```
def f(n, a, b):
    # reverse the string to that the least significant place is leftmost
    # Ex: 985724 -> 427589
    n = n[::-1]
    # get the value of each place, which is its index in the InputFormat, times the base to the power of the place
    # Ex: 427589, 9876543210 -> 5*10^0, 7*10^1, 2*10^2, 4*10^3, 1*10^4, 0*10^5 -> [5,70,200,4000,10000,0]
    n = [a.find(j)*len(a)**i for i,j in enumerate(n)]
    # add all of the values together to bet the value in base 10
    # Ex: (5 + 70 + 200 + 4000 + 10000 + 0) = 14275
    n = sum(n)
    # call the convert to base function
    return g(n, b)
def g(n, c):
    # string slice, which will return an empty string if n:n+1 is not in range
    # an empty string is falsey
    if c[n:n+1]:
        return c[n:n+1]
    else:
        # get current least significant digit
        rem = c[n%len(c)]
        # get the rest of the integer
        div = n/len(c)
        # get the converted string for the rest of the integer, append the calculated least significant digit
        return g(div,c)+rem
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 11 bytes
```
iⱮ’ḅL{ṃ⁵ṙ1¤
```
[Try it online!](https://tio.run/##y0rNyan8/z/z0cZ1jxpmPtzR6lP9cGfzo8atD3fONDy05P///@qWFuZmpibGRoYG6iCOqbmRCZBhYGhkbGJqZm5h6ejk7OLqpg4A "Jelly – Try It Online")
Argument order: InputFormat, Number, OutputFormat. **Be sure to quote the arguments with proper escaping!**
[Answer]
# Pyth, 21 bytes
```
s@LeQjimx@Q1dhQl@Q1le
```
[Test suite](https://pyth.herokuapp.com/?code=s%40LeQjimx%40Q1dhQl%40Q1le&test_suite=1&test_suite_input=%221%22%2C%220123456789%22%2C%229876543210%22%0A%22985724%22%2C%229876543210%22%2C%220123456789ABCDEF%22%0A%22FF%22%2C%220123456789ABCDEF%22%2C%220123456789%22%0A%22FF%22%2C%220123456789ABCDEF%22%2C%2201234567%22&debug=0)
Explanation:
```
s@LeQjimx@Q1dhQl@Q1le  | Code
s@LeQjimx@Q1dhQl@Q1leQ |  with implicit variables
       m               | Map the function
        x   d          |   index of d in
         @Q1           |    the second string in the input
             hQ        |  over the first string in the input
      i                | Convert the resulting list to int from base
               l@Q1    |  length of the second string in the input
     j                 | Convert the int into a list in base
                   leQ |  length of the last string in the input
 @LeQ                  | Turn each number in the list into the character from the numbers index in the last string in the input
s                      | Concatenate the strings in to one string
                       | Implicit print
```
[Answer]
# [Haskell](https://www.haskell.org/), 119 bytes
```
n!f=init.((foldl((+).(l f*))0[i|c<-n,(i,d)<-zip[0..]f,d==c],0)#)
(0,d)#b=[b!!d]
(r,d)#b=r`divMod`l b#b++[b!!d]
l=length
```
[Try it online!](https://tio.run/##fY7BToNAEIbvPMUgHnYFNguFAgnbRKuc7MkjEgtdKBu3C4HVJsZ3R7QeSEycw2T@75vD35bjay3lNCmzYUIJTRBqOsklQjYmSEJzgzHNxechdZWDhMNx6n6IPqeEFI3DGTsUDsUWNhCdnVWxvDJNXhhouMRhz8X7ruN7CZVV2favlkzW6qjb6VQKBQxOZb97AYSec@U0ji7cTf@mn/TwqOAaxrY7A/oRGGwbrsDdzGu@0Fwbz5DAuRv4iA34HgJSqHq8BJamcKz1tlO6VnqcPKCevwrCdRQnkMTROgxWvkeNJA4jP1iQxd/t3fb@ITOy7A9bgH/1Fw "Haskell – Try It Online")
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~100~~ 97 bytes
```
{$^c.comb[(":"~$^b.chars~[$^a.comb>>.&{index $b,$_}].perl).EVAL.polymod($c.chars xx*)].join.flip}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/WiUuWS85PzcpWkPJSqlOJS5JLzkjsai4LlolLhEsYWenp1admZeSWqGgkqSjEl8bq1cANEJTzzXM0UevID@nMjc/RUMlGaJPoaJCSzNWLys/M08vLSezoPZ/cWKlQpqGkqGSjpKBoZGxiamZuYUlkGNpYW5mamJsZGigpGnNBVVlaWFqbmSCKousz9HJ2cXVDUmDmxs2eRSriFcMVPofAA "Perl 6 – Try It Online")
Anonymous code block that takes 3 strings in order, input, input format and output format, then returns a string
### Explanation:
```
{  # Anonymous code block
  $^c.comb[  # Split the output format into characters
           (":"~$^b.chars~[$^a.comb>>.&{index $b,$_}].perl) # The radix syntax in a string e.g ":3[1,2,3]"
           .EVAL  # Eval'ed to produce the base 10 version
           .polymod($c.chars xx*)  # Converted to a list in the output base (reversed)
          ] # Convert the list into indexes of the output format
           .join  # Join the characters to a string
           .flip  # And unreversed
}
```
[Answer]
# VBA, 182 bytes
A declared subroutine which takes input, `n`, in the language `y` and projects that into language `z`.
```
Sub f(n,y,z)
l=Len(n)
For i=-l To-1
v=v+(InStr(1,y,Mid(n,-i,1))-1)*Len(y)^(l+i)
Next
l=Len(z)
While v
v=v-1
d=v Mod l+1
v=v\l
If d<0Then v=v+1:d=d-l
o=Mid(z,d+1,1)&o
Wend
n=o
End Sub
```
[Answer]
# JavaScript (ES6), ~~90~~ 86 bytes
Takes input as `(input_format)(output_format)(number)`.
```
s=>d=>g=([c,...n],k=0)=>c?g(n,k*s.length+s.search(c)):k?g(n,k/(l=d.length)|0)+d[k%l]:n
```
[Try it online!](https://tio.run/##lc5dC4IwFAbg@36FDIItbX6uWTCjLP@EeCHzo3LMcNJV/90QjbK66dwdznkf3kt6SxVvztd2Kess7wrWKRZkLCgZjLmBMZaJUTELsYBvSyiNaqGwyGXZnnSFVZ42/AQ5QptquJpQsGx8QHcL6VlczUWykR2vpapFjkVdwgICy3Zcj6yovwYIgrVPV8RzHdvqNxsgpL2NaWrAB7MPYZp5ebt9eDhGg0qo4/VYL7g0dL@QX7FptSh6tukRh5C/jKmgjUUo6B4 "JavaScript (Node.js) – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 130 129 bytes
```
v;c(r,i,s,t)char*r,*i,*t;{for(r[1]=v=0;*i;v=v*strlen(s)+index(s,*i++)-s);for(s=strlen(t),i=1;*r=t[v%s],v/=s;memmove(r+1,r,++i));}
```
[Try it online!](https://tio.run/##lVDLbsMgELz7KxBSJLA3inGclyiHvvITDofIIS1SbFdAUdUo3@7ivBP1Eg4sDDPM7pT9j7JsW89LYkCDBUfLz6WJDcQaYse368YQUzApvEh5rLkXPrbObFRNLE10vVI/xAZyktC@pbyjW3EkOApaMB4b4QrfsxL8QFheqapqvCImYWAgSTSlfNd2rih2yrpyaZUtZDGUSETbCIW1RZhhwCnLhvloPJnOwmU2nYxH@TBjKUY7ONFm09Eky2@fr4XPL69v7/NrxXz@H@HG7AF24EY7HkW6dqha6pr4Rq/ocYz9jEbZ740rWJrlMhA7PISGSKfQSKCUh/KErP5VzRqdA0GDE3QJiaMuvUNr@31vQg4OcNEWWhapvAPYPZBJys@/fJnQz5pgssA9u8BwU2ho83Ba1BjOmtN62BeOoRz9Q4LtHw "C (gcc) – Try It Online")
-1 byte using `index` instead of `strchr`.
This is a simple iterative approach, reusing some variables (and thereby abusing `sizeof(int) == sizeof(char *)` on TIO) to save bytes.
Input:
* `i` input number
* `s` source base characters
* `t` target base characters
Output:
* `r` result number (pointer to a buffer)
### Explanation:
```
v;                                        // value of number
c(r,i,s,t)char*r,*i,*t;{
    for(r[1]=v=0;                         // initialize value and second
                                          // character of output to 0
        *i;                               // loop while not at the end of
                                          // input string
         v=v*strlen(s)+index(s,*i++)-s);  // multiply value with source base
                                          // and add the value of the current
                                          // digit (position in the base string)
    for(s=strlen(t),i=1;                  // initialize s to the length of the
                                          // target base string, length of
                                          // result to 1
        *r=t[v%s],v/=s;                   // add character for current digit
                                          // (value modulo target base) and
                                          // divide value by target base until
                                          // 0 is reached
        memmove(r+1,r,++i));              // move result string one place to
                                          // the right
}
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~97~~ 95 bytes
Thanks to Chas Brown for -2 bytes.
```
n,s,t=input()
k=0;w='';x=len(t)
for d in n:k=len(s)*k+s.find(d)
while k:w=t[k%x]+w;k/=x
print w
```
[Try it online!](https://tio.run/##hY5ZT4NAFIXf51eMYxqhxQoUOtBmEruAu3Wpa9OYFqYWqQMOU6EafzuC@mATE1/uvefkyz0nXol5xPTci3xKEEI5UxJFkIDFSyHJICRqOyVbW@2MLCiThAxmEYc@DBhkrfDLS@RqWEvqs4D5ki@DdB4sKAxbKRGjsJKNa2k73CEZiHnABEzzIgP8QEO@pC0AoeCrckFIM@rBsgkob4/GAjoD1@E84t/AlNNJCHKkIQWpmt4wzCa27ELYFm6aRkPXVAQKYWLdWHd/851ur@@4Bei6f/lrr/@HEJCQZhkmLodh2VjTDQtjXTMxUuB6zc5E7U61nqf3/YZDDXdm7j029@f4ILAOn@yjUDle1E@eR6dsPIh2z@LN85ePC/5@mWwPRe1qSa5fH27Sjduscreq3r8h@RM "Python 2 – Try It Online")
[Answer]
# Java 10, 131 bytes
A lambda taking the parameters in order as strings and returning a string.
```
(i,f,o)->{int n=0,b=o.length();var r="";for(var c:i.split(r))n=n*f.length()+f.indexOf(c);for(;n>0;n/=b)r=o.charAt(n%b)+r;return r;}
```
[Try It Online](https://tio.run/##hVDLasMwEDzHXyEMBalxXOedVDiQPgI9lBxyLKVIjpUoddZGXpuW4G935bwO7aGwsDuz2tnV7EQpOrv1Z50VMtERiRKR5@RVaCAHp3UmNWBslIhismjYC71Co2FDohTK2CA9Qw1Zgd6lqVKzF/gCv4hlgYw7rcq57shRoE1Kg0jsGkXCmmpPeSnrzA72AAJh4Mkw9ZMYNriljJfCEBO6LreStAHRvfbzLNFIDWMQwq26Pm4rX8M6/loqGrHjAIdZwOEulMxY0WgrzBwp3EjWNtzEWBgghld1i/85sUz1muytQ@cfv70TYTY5O1qz@s4x3vtpgX5mm5gAVf7FIXc6GY57A9ezxXg0HPR73cCCoNvrD4aj8WQ6f3h8el64rPHmHykhpQ3XI@6HOCUpToOVU9U/)
## Ungolfed
```
(i, f, o) -> {
    int n = 0, b = o.length();
    var r = "";
    for (var c : i.split(r))
        n = n * f.length() + f.indexOf(c);
    for (; n > 0; n /= b)
        r = o.charAt(n % b) + r;
    return r;
}
```
]