[Question]
  [
Given a list of positive integers \$\mathcal I=I\_1,I\_2,I\_3,...,I\_n\$ and a base \$b>1\$ return their "carry-less sum", i.e. represent \$\mathcal I\$ in base \$b\$ and sum digit-by-digit discarding carry.
Worked example:
```
I = 13, 2, 9; b = 3
```
In base 3:
```
   111
 +   2
 + 100
 -----
 = 210
```
and back to base 10:
```
desired output: 21
```
More test cases:
```
I=[1000, 576, 23, 1, 141], b=12 => 1573
I=[1000, 576, 23, 1, 141], b=2 => 307
I=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], b=4 => 11
I=[1, 2, 3, 5, 8, 13, 21, 34, 55], b=5 => 77
I=[900, 100], b=10 => 0
```
This is code-golf shortest function or program per language wins.
Standard rules and loopholes apply.
  
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), 11 bytes
```
{x/x!+/'x\}
```
[Try it online!](https://ngn.codeberg.page/k#eJx1zDESwjAQQ9E+p/hUwFDY8nqzgbNQ5wyeYbg76wyUqNWT9sdrlHG6lfN4vpflsqN2RbVWPFaaIdTFkYI8bKL/JpHVmKanoWF0nJVg456r75Em8R/xLGU0Yan9IBEfTF4cRw==)
First time writing a curried function in K...
Works exactly like [coltim's answer](https://codegolf.stackexchange.com/a/251295/78410), except for how the function is called. This one is a monadic function that takes the base and returns another monadic function that takes an array and returns the answer. You can call it like
```
(f 12) 1000 576 23 1 141
f[12][1000 576 23 1 141]
```
[Answer]
# [Python 3](https://docs.python.org/3/), 56 bytes
```
f=lambda I,b:sum(I)and sum(I)%b+b*f([x//b for x in I],b)
```
[Try it online!](https://tio.run/##jcvRCoIwFMbx@57iuwm2OuCmTivwAfYM4oVDRkJOMQN7@nWyuyAIzsXH4fefnst1DFmMvrq1g@taWHKX@2MQVrahw2ft3dEdvKjXJHHw44wVfYBtyMk4zX1YhBe2qrVSimDKgpBmBM2X64bgKp1KuftLfkMGBCY5cwL7knAinLlQW5D/CMzmNK@Uf9m7N1tgpIwv "Python 3 – Try It Online")
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 18 bytes
```
R($+R*:SgTDa)%aFDa
```
Takes the base, followed by the integers, as command-line arguments. [Try It Online!](https://dso.surge.sh/#@WyJwaXAiLCIiLCJSKCQrUio6U2dURGEpJWFGRGEiLCIiLCIiLCIxMiAxMDAwIDU3NiAyMyAxIDE0MSJd)
### Explanation
> 
> [This challenge is] a good example of why base-conversion builtins should be little-endian  
> 
> - [ais53](https://chat.stackexchange.com/transcript/message/61848059#61848059)
> 
> 
> 
```
R($+R*:SgTDa)%aFDa
                    a is first command-line arg; g is list of args
       Sg           All but the first command-line argument
         TDa        Convert each to a list of integers representing base-a digits
    R*:             Reverse each list of digits
  $+                Add the lists of digits together itemwise
 (          )%a     Take each digit sum mod a
R                   Reverse again
               FDa  Convert from base-a digits to decimal
```
[Answer]
# [R](https://www.r-project.org), 42 bytes
```
`/`=\(I,b)`if`(s<-sum(I),I%/%b/b*b+s%%b,0)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=hY_BCsIwDIbvPkVACu3MWLOtdoL13nfwUCoUPHhx7mm8TMH38erbGLcp4kUIJPx8X0LOl2N_Te7WnVLePLJQBLeVHqMK-xRku87b7iC9Qi8KEYuYxUUrREStJuOepHc7SVprBGOXCGWFQFw1KYToqFRzcBsgY6vZP3hiK23fKCMIDNUsILBhERqEFTt6UOppPf0aZgCJp5Kz6rXADIYZDfu58Z3S-Fffj_0J)
The same approach as other recursive answers.
Renaming the function to `/` makes `I%/%b/b*b` evaluate in the correct order (first `%/%`, then `/`, then `*`) and saves a byte compared to `f(I%/%b,b)*b`.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
bUS%Uḅ
```
[Try it online!](https://tio.run/##y0rNyan8/z8pNFg19OGO1v@Hl@trRv7/H80VHW1oYGCgo2BqbqajYGSso2AIRCaGsUDSKFYHjzRUFsjQUQCKmwDV6CgAFZnrKFjoKFgClRkAVZmgqjIFSxoCWUZAMWOQJlOgKtNYrlgA "Jelly – Try It Online")
```
b         Convert each to base b
 U        reversed,
  S       sum corresponding digits,
   %      mod b,
    U     reverse back to big-endian,
     ḅ    convert from base b.
```
> 
> a good example of why base-conversion builtins should be little-endian
> 
> 
> 
-- [ais523](https://chat.stackexchange.com/transcript/message/61848059#61848059)
Incidentally, having to reverse twice only costs one byte due to dyadic chaining rules requiring something between `%` and `ḅ` anyways, but in cases like this I'd have to agree that
> 
> I like the monadic link rules, but not the dyadic link rules
> 
> 
> 
-- [ais523](https://chat.stackexchange.com/transcript/message/57320257#57320257)
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 19 bytes
```
ＷΣθ«⊞υι≧÷ηθ»Ｉ↨⮌﹪υηη
```
[Try it online!](https://tio.run/##HYy7DoIwFEBn@hV3vE3qoEyGycfiQEJwJAwNNPQmtZW@HIzfXtHlnOXkTFr6yUlTykuTUYD39MCVc3izqktBYxJAvGFVK5@nEGixPS064s3GK2WalQAtYN2KD@s82YgXGSKeZVDYq6z85tbNybjfSXP@B29KGYZ9LeAg4DgKqMeyy@YL "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
ＷΣθ«
```
Repeat until the (sum of the) input list is zero.
```
⊞υι
```
Push the sum to the predefined empty list.
```
≧÷ηθ
```
Vectorised integer divide the input list by the input base in place.
```
»Ｉ↨⮌﹪υηη
```
Vectorised modulo the list of sums by the input base, then interpret that as a number in the input base, and output the result. (The `Reverse` is there because base conversion isn't little-endian as it "should" be...)
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 8 bytes
```
τR∑Ṙ$%¹β
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLPhFLiiJHhuZgkJcK5zrIiLCIiLCIxMlxuWzEwMDAsIDU3NiwgMjMsIDEsIDE0MV0iXQ==)
[Answer]
# [J](http://jsoftware.com/), 14 bytes
```
[#.[|[:+/#.inv
```
[Try it online!](https://tio.run/##JYyxDsIwDET3fMWVDhHCBLsNLbHEhMTExBoxISpggI2p/566VDov957vXVKlcusqTd67VfADjgoPAkPttgGn6@Vcch3ymHWzq8Pr8ytr5x735xctBkhLaAhpaaSZK2Ym7PvOiFGxRFl4nPH/wUA0iWBWTzjYhHlcJg "J – Try It Online")
* `#.inv` base digits
* `[:+/` sum elementwise
* `[|` mod by base
* `[#.` back to base 10
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), 12 bytes
```
{y/y!+/'y\x}
```
[Try it online!](https://ngn.codeberg.page/k/#eJyFzz1PwzAQBuA9v+KQkGiEU+fsuE5jlZ2drVRqGpw26kcgTlGiCn47Z3ehA2L1+9yd37q4jHy8e+QP4+vwFUUvxeV+OX53RQ1TGMy63ZvJui6bgxnMaLp45c1yghIEzI2MjcBVeEjTFJSegZCAgBkaFLFBpeUfMaUy1deQdknIQMEMNOQwB0xNRtP4K1YU+KsIkqQyKjaaxiMe7fr+3RWcV+2b3baHeur6strbodqVp62dVu2Rf5yt65v25LhQKHLJq7LrxuRgnUvc+Zhsm097SspkUzqbbKLoebFEyUAwmK8YbBYSFk90+hpQFea7UE4Gma8TFArPfOd/YHDU/srCHQIZYQakNYOcLpNPA8/CWrzVKqDwS3qTflgFrbzW+gcuOm6M)
* `y\x` convert list input `x` to base-`y`
* `+/'` sum each "row" of the above
* `y!` mod the sums by `y`
* `y/` convert back from base-`y` (to base-10)
[Answer]
# JavaScript (ES6), ~~53~~ 52 bytes
Expects `(base)(list)`.
```
b=>g=a=>(a=a.map(n=>(s+=n,n/b|0),s=0),s&&s%b+b*g(a))
```
[Try it online!](https://tio.run/##jc2xDoIwEIDh3ae4RdLKCS1Qq0N5EeNQEIgGC7HGyXfHq9FEmWya5tLk@@9s79bX19N4W7vh2EytmSpTdsaaklljk4sdmaPZx8ahS6uH4OhNeKLIL6u4WnXMcj7Vg/ND3yT90LGWyYyzvRRCICi9QchyBEm3kAfO4XPSFKTS@eLXwr82F3pOi0CJIBAqKIBABY2wRdhRQ4REWCvnUn1L9QKSpoz@8hBSb6n19AQ "JavaScript (Node.js) – Try It Online")
Or **51 bytes** with BigInts:
```
b=>g=a=>(a=a.map(n=>(s+=n,n/b),s=0n),s&&s%b+b*g(a))
```
[Try it online!](https://tio.run/##nc5BDoIwEAXQvafoRtIKQgvU6qJcxLhoEYgGB2KN18cZdANLm/xJm@a/zN29Xaift/G1h@HaTK2dvK0662zFnXXpw40c8B5iCwlkXiTBSsAZRWHrY7/ruBNiqgcIQ9@k/dDxlqscBD8rKSUkTJsDzrzAoSilgosQbHGyjCltis2SYX8whTRrpZwVKmOoXxKHIdBgjpgTmXImaRm1RvQa0b@iokdOP8Xs6u9aiBgzfQA "JavaScript (Node.js) – Try It Online")
### Commented version
```
b =>            // outer function taking the base b
g = a =>        // inner recursive function taking the list a[]
( a =           // update a[] (and compute the sum at the same time):
  a.map(n =>    //   for each entry n in a[]:
    ( s += n,   //     add n to the sum s
      n / b | 0 //     compute floor(n / b)
    ),          //
    s = 0       //     start with s = 0
  ),            //   end of map()
  s &&          // if the sum is not 0:
    s % b +     //   compute the sum modulo the base
    b * g(a)    //   add the product of the base and the result
)               //   of a recursive call with the updated list
```
[Answer]
# [PARI/GP](https://pari.math.u-bordeaux.fr), 34 bytes
```
b->g(a)=if(a,g(a\b)*b+vecsum(a)%b)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=dY5NCsJADIWvEgpCR1Po9MfWRXuRcZAZsaWgMtRW8CxuCiJewMt4G1-1GxdCSF7e-wK5Ppxpm03thltFxb3vqiB_eTYoa9-Ioql8w1BrK-Z2cd5tT_0B_syKiXwa5_YX31BQkmubYwfpjYtHOFWRFuhSC8GklJJhGDKl2ZIpipkkKpEaPdJj_i-eUggm-AkYJkAZU860AhaCSH6p9BNKqAhePB6lIFKtp9-H4Tvf)
A curried function that takes input as `(base)(list)`.
[Answer]
# [Desmos](https://www.desmos.com/calculator), 77 bytes
```
k=[0...floor(max(log_bl))]
f(l,b)=total([mod(floor(l/b^i).total,b)fori=k]b^k)
```
Function \$f(l,b)\$ takes in a list of positive integers \$l\$ and a base \$b\$.
Not too sure what little endian big endian is all about so I just did it my own way.
[Try It Online!](https://www.desmos.com/calculator/tchugtvooo)
[Try It Online! - Prettified](https://www.desmos.com/calculator/vqcwkhh9cm)
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 52 bytes
```
Total@PadLeft@IntegerDigits@##~Mod~#2~FromDigits~#2&
```
[Try it online!](https://tio.run/##dc29CsIwFAXg2T6FEOh0hfw0rR2UDCIICgXdxCG0aQ3YFurdavPqMVVwczznO9zbarybVqMtta83/tKjfqhCV0dTozp0aBoz7Gxj8akIcae@coS7/dC33zKk2BeD7fBKVttaKXKL3bnUnRujkQngkE@LxWspIERKKcgsBS6AAUvYFIDxf/KBcEBAAhJSyGANOTA6W/IzGdr5DwMRZnJGGU3@DQ "Wolfram Language (Mathematica) – Try It Online")
Input `[I, b]`.
[Answer]
# [Nibbles](http://golfscript.com/nibbles/index.html), ~~10~~ 9 bytes (18 nibbles)
*Edit: -2 nibbles thanks to bug-fix in nibbles compiler (thanks [Darren Smith](https://codegolf.stackexchange.com/users/94929/darren-smith)!) allowing  ``@` (convert from base) to work correctly on 2d lists*
```
`@@.\`'.$\`@_$%+$_
```
```
       .                # Map over 
        $               # the elements of arg1
         \              # reversing
          `@ $          # the digits in base
            _           # arg2.
     `'                 # Now transpose this,
    \                   # reverse it,
   .                    # and map over each list
               +$       # sum
              %  _      # modulo arg2.
`@                      # Finally, convert from base
  @                     # arg2
```
[![enter image description here](https://i.stack.imgur.com/E6jeM.png)](https://i.stack.imgur.com/E6jeM.png)
[Answer]
# [Haskell](https://www.haskell.org/), ~~54~~ 51 bytes
```
b!l=sum[b^w*mod(sum$map(`div`b^w)l)b|w<-[0..sum l]]
```
[Try it online!](https://tio.run/##hY7LCsJADEX3/YoruFBJZR4dx4J@SanYUsHiTCvWx8Z/H@O4sK6ELELuOUmO1XA6OBdCPXHb4eaLevdY@L6ZcT/11Xm2b9r7nodzN6@fj01aiOWSM7iyDL5qO2zR9AnOl7a7YgpoTFBITYryEmkKJb@hVDEUQhCMXRGUJkiuTEZWGquT0a4/uBZ2TGeRZorAXMYOgSVLWBNy1sTniBxL5kcykeXv@W0evHeYKFmbhBc "Haskell – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~88~~ 73 bytes
```
i;s;f(l,b,n)int*l;{for(s=i=0;i<n;l[i++]/=b)s+=l[i];s=s?s%b+b*f(l,b,n):0;}
```
[Try it online!](https://tio.run/##lVPZbtswEHzPVywECNBBIzqrJoyah6JfYQuBRVOpEJs2TAV1a/jXqy4P2QqRlwq26N2ZWS5nabZ4ZWwceyppF2xJS0TYiyHa0nO3Pway7uuE9k@Cbpd9HDf3dRvKuMagobKWz9Jv4zaahI8JvYyoht26F0EI5zvARyUGLoeXZNlADec0J5AReLjQj3Bq4SRJCJTVF2QhM8VPkbrc7D@4ueXqXZFVoIIASioCX7EPFCWupnA0pabqzjGXqxKlq2mNRvWRaZ1i3UiRZklDMn4Qe3C7ZnbN7Vq4Owgjlv0fvu8CUyO8t2FkYwJzPHXw1MEzB88cPHfw3MELBy/CWdP8dOBs4BvTtnIuLSs8XZ6g9SmGVWXZbC/kAOzn@hjhm7M3fjQib3X6ka1OD9/xW3oE5nHuWTXeVAjUhr3Y8BPKEmp/Pk3NTq3c2r1mKMSxZoe6mLm0t6FhOTM4zWnoHAZhURzNZ3D73nVLMUvu@I4dfgcqj0PGKxKJ0JFMFdtPK0qEO6tvCbhqjvDVdVd/s8lahPYIffrwylHP4YikLvB86W/Q8v5Z@f7oLXEZ8I8/23JiNgT8DSy@qbcvV8LTzUlynSWvazkJL3eX8S/rtutXOS5@/QM "C (gcc) – Try It Online")
Inputs a pointer to an array on integers, a base, and the length of the array (because pointer in C carry no length info).  
Returns the carry-less sum.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 10 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
вí0ζOR¹%¹β
```
Inputs in the order \$b,\mathcal I\$.
[Try it online](https://tio.run/##ASQA2/9vc2FiaWX//9Cyw60wzrZPUsK5JcK5zrL//zMKWzEzLDIsOV0) or [verify all test cases](https://tio.run/##yy9OTMpM/V9WmWCvpJCYl6KgZA9kPGqbBGRUJhxa@f/CpsNrDc5t8w86tE710Lpzm/7r/I@OjjY01jHSsYzVMY7VUQDyDAwMdEzNzXSMjHUMdQxNDGN1DI1wyUAlgPqNdUx0THXMdMx1LHQsdQwNYnVMkORMgaIgawx1jIHKTGN1TMGSlkADgabGgtTHAgA).
**Explanation:**
```
в          # Convert the values in the second (implicit) input-list to the base of the
           # first (implicit) input-integer as inner lists
 í         # Reverse each inner list
   ζ       # Zip/transpose; swapping rows/columns,
  0        # with 0 as trailing filler digit for unequal length lists
    O      # Sum each inner column-list
     R     # Reverse the list back
      ¹%   # Modulo each value by the first input-base
        ¹β # Convert this list from the first input-base to a base-10 integer
           # (which is output implicitly as result)
```
[Answer]
# [Perl 5](https://www.perl.org/), 52 bytes
```
sub f{$b=pop;&sum&&&sum%$b+$b*f((map$_/$b|0,@_),$b)}
```
[Try it online!](https://tio.run/##hZFRS8MwEIDf@yuOEUurEZOmsa4luh@gjz7NUQy0UlybkHagzP116yVzD@5FSMLlvi93B7GN28p5Hnca2j3RyhpbxeOuj2N/XhB9RfRlmyT9qyX1DdFfjK7qlBKdHubWuCQCWK@5oJBRWG4oCFD3kPENPQLGGAVZ3CJHh@PKkQHPvMZlIf4RgydYcdJCHxRylCmgXVC4w87oM9TzUJaf2zJIYUrMCf9Yoi29XZxqL/0EOIcfj3nCfkF2DgTGUbpH2H8mQDoKRONuPiykoGBF6iowIG9mwkSbYC5YkHpiXTdMAf69gVLHKg@wAPP@MiygxKhxzji8VNFh/jZ26swwztdPj904leXz1G0V/tQP "Perl 5 – Try It Online")
```
sub f {
  $b = pop;                  #extract the base $b from the end of the param list
  &sum                       #&sum returns the sum of the input list @_
                             #since &sub without parens uses @_ as params 
                             #if sum > 0
  &&
  &sum % $b +                #then return last base $b digit of the sum plus
    $b *                     #$b times 
    f( (map$_/$b|0,@_), $b ) #the recursive result for the same list
                             #but with last digit removed from each list elem
                             #else return 0
}
```
[Answer]
# [PowerShell Core](https://github.com/PowerShell/PowerShell), 129 bytes
```
param($n,$b)$r=@{}
$n|%{do{$r[$i++]+=$_}while($_=[Math]::Floor($_/$b))$i=0}
$l=$r.Count
-join($r|% V*|%{"+$_%$b"+"*$b"*--$l})|iex
```
[Try it online!](https://tio.run/##jZFBS8NAEIXv@RVDmWq22WjWtkaFQLDoTRQVL6WUJF1pJM3WTYJCmt9eZxOtVTw4hOzy5ntvBnat3qQuljLL3ERpucXnoN6uIx2tbMw5xgx1ENaNhfmmXy9UjXqKqePMnADnzdsyzaSN82B6E5XL2cXFdaaUJuGYjAzTwCNjFqA@mqgqLy33RaW5jXrTh6cB5fUcnPcx7jm9Af0HrotZwzapfN82lhXaFlBxCO3QFkMOJxzOGQdzE2y/53keh7F/Sg1qCvpGgkBBBjH2h/9hCR16/g@yEzmMiOdABp/DGa1AFo@1shB/GsYt125M2tD4x6yVff/XLhTnmTBBN49ZDDZwrfRVlCzd2/hFJiXUrQHzahXTO3HAOCokHfJ9TW25gABw3jFaFlVWknCAzztHZ2iB6d3DpCpKteqiZ2GXbeqhShJZFGDSPmNc@fo9ZQc@yqKcUKABvya0rwqHHA5hx10axlSwt4Cp@y59b1Lbaqxm@wE "PowerShell Core – Try It Online")
[Answer]
# [Prolog (SWI)](http://www.swi-prolog.org), 76 bytes
```
I+B+O:-sumlist(I,S),S>0,maplist([A,A//B]>>!,I,Q),Q+B+W,O is S mod B+B*W;O=0.
```
[Try it online!](https://tio.run/##Hcu9CoMwGEbhW/m6afOqif0DSwNmyxQkg4M4CIUSMI0YSy8/lcKZHjjLGubwKuLXpaSZYqYp4sfPLm6Zhs1hJYeflj8MLdqqUqOUB2h0Obp96GHIRbLkw5MUU8f@bh68TE1Bg@Ccgy63K6g@gcTeWYysZga0rO69ZSYv0w8 "Prolog (SWI) – Try It Online")
-3 thanks to Jo King
More interesting, without `sumlist` or `maplist`:
# [Prolog (SWI)](http://www.swi-prolog.org), 86 bytes
```
E+H-[H|T]-B-[H//B|Y]:-E-T-B-Y.
0-A-_-A.
I+B+O:-S-I-B-Q,S>0,Q+B+W,O is S mod B+B*W;O=0.
```
[Try it online!](https://tio.run/##DYnLCoMwEEX3fsUs22YmJvYFKS0YEHQVJIKIhG4KJdA2ooVu/Pc0cOFwzp3m8ApPWn4@xorVNNZr50gn5rleB6eooi75wDNBJd2p5FnDNDOKLDXpaNHeBLYp9WjAL2DhHR6gmd71F3MVPCqCUQohEI7nE0KxR5BpB@lYwQzCNPvPd2O2PP4B "Prolog (SWI) – Try It Online")
[Answer]
# [Julia](http://julialang.org/), 35 bytes
```
i^b=any(i.>0)&&sum(i)%b+b*(i.÷b)^b
```
[Try it online!](https://tio.run/##hctBCgIxDAXQvafIxqHVIEmndXShFxEL011kLIM6oCfzAB6spu4EQcji8//LaRqk53spEtOuzw8jqz3ZprlOZyN2npZpodXrmWxMZbxIvg3ZHJiIEEK3RnAtAut5PkIEdnb2X30hHRF09koR1HYIG4StaqrY/8LhY1iT066tv6HiYMsb "Julia 1.0 – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 161 bytes
```
\d+
$*
{`^([1,]+)(;1+)
$1$2;$1
T`,`_`;.*
^([1,]+;(1+);)\2*
$1
\G((?=.*?;((1)+))\2|1|(,))
$3$4
}`^,+;
;
{`\G(;1+;)|1(?<=(1+);1+)(?=1*;)
$1$2
}`^(;1+;1*);
$1
r`1\G
```
[Try it online!](https://tio.run/##dY27TgNBDEV7f4WLQfLMWNF6HwmRibbMD9CxhEEiRZoUER2bb1/uDkhUSHZzz/H17fx5ub4vD1KYlukjU0j0VU7yYvqao7jlSMFC68HouWh5K75J9MtdgD1ObYJD01FkPGzS6CIWc0Q@2ywa0dCFnu7lpNnJ0Q8VzR5nk/HpUFuwuLbkP/9WuzqWoq/tt2LTcVmsU26V984dWdM0ysNuiwixYXpztvY/AlCvEfXAyuA75Uf0wWic@z9hqHl9h6xb/cF5@AY "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
\d+
$*
```
Convert to unary.
```
{`
}`
```
Repeat until all of the input numbers have been reduced to zero.
```
^([1,]+)(;1+)
$1$2;$1
```
Duplicate the input list.
```
T`,`_`;.*
```
Sum the duplicate copy.
```
^([1,]+;(1+);)\2*
$1
```
Reduce it modulo the base.
```
\G((?=.*?;((1)+))\2|1|(,))
$3$4
```
Integer divide the list by the base.
```
^,+;
;
```
Remove the list if it's zero.
```
{`\G(;1+;)|1(?<=(1+);1+)(?=1*;)
$1$2
}`^(;1+;1*);
$1
```
Convert the sums from the input base.
```
r`1\G
```
Convert to decimal.
[Answer]
# [Factor](https://factorcode.org/) + `math.unicode`, 72 bytes
```
:: f ( I b -- n ) I Σ dup 0 > [ b mod I [ b /i ] map b f b * + ] when ;
```
[Try it online!](https://tio.run/##dc7BTsMwDAbg@57i3w2YNuKmWaATu6Jedpk4oR1Km7KKLiltKjRNPA3vwyt1bqvtgESkRLbz2XKepN7V3cs23jxH@DC1NSVKlyZlg0Pi98OzaG2Rusygqo33x6ourEdjPltjU9NghXgT4d2VeRdFyHGDGG@Yz2Fxy@HvD7K2gsAar1w/uIyLfXRfYMfzKw5zvneYcf61Nxar7gSSCPCIb0j@XeDPmeJpjYAm7IQQUHqJQIJAIXELBZeewZHS8h95haOUQveQyxIhFJbQeOAtSLANRzuOpKtTLPplCZJbFEM1wMFp3Z0B "Factor – Try It Online")
* `:: f ( I b -- n ) ... ;` Define a word (function) named \$f\$ that takes two arguments from the data stack and returns one. The double `::` as opposed to `:` enables lexical variables inside the definition.
* `I Σ dup 0 >` Is the sum of \$I\$ greater than zero?
* `[ ... ] when` If so, then call `[ ... ]`.
* `b mod` Take the sum of \$I\$ (which is still on the data stack thanks to `dup`) modulo \$b\$.
* `I [ b /i ] map` Divide each number in \$I\$ by \$b\$ (integer results only) and place the result on the data stack.
* `b f` Call \$f\$ on the above list with the same original base, \$b\$.
* `b *` Multiply the result of the above call by \$b\$.
* `+` Add the sum of \$I\$ modulo \$b\$ which is still on the data stack.
[Answer]
# [Knight](https://github.com/knight-lang/knight-lang), 109 bytes
```
;=j!=bP;W=xP E++"=x"=j+1j"Ex";=r=m=s 1;Ws;=s=i 0;W<i j;=s+sE+"x"=i+1iE++++"=x"i"/x"i" b";=r+r*m%s b=m*m bO-rT
```
[Try it online!](https://knight-lang.netlify.app/#WyI7PWohPWJQO1c9eFAgRSsrXCI9eFwiPWorMWpcIkV4XCI7PXI9bT1zIDE7V3M7PXM9aSAwO1c8aSBqOz1zK3NFK1wieFwiPWkrMWlFKysrK1wiPXhcImlcIi94XCJpXCIgYlwiOz1yK3IqbSVzIGI9bSptIGJPLXJUIiwiMTJcbjEwMDBcbjU3NlxuMjNcbjFcbjE0MSJd)
-1 byte thanks to Aiden Chow
[Answer]
# [APL (Dyalog Classic)](https://www.dyalog.com/), 20 bytes
```
0{⍺⊥⍺|+/⍵⊤⍨⍺⍴⍨⌈⍺⍟⌈/⍵}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v8/LzmxqKjyUduE6ke9ux51LQWSNdr6j3q3Pupa8qh3BUiwdwuI0dMBZs8HMkDStf//AwA "APL (Dyalog Classic) – Try It Online")
**Usage:**
```
      ncarry←{⍺⊥⍺|+/⍵⊤⍨⍺⍴⍨⌈⍺⍟⌈/⍵}
      3 ncarry 13 2 9
21
      12 ncarry 1000 576 23 1 141
1573
      2 ncarry 1000 576 23 1 141
307
      4 ncarry 1 2 3 4 5 6 7 8 9 10
11
      5 ncarry 1 2 3 5 8 13 21 34 55
77
```
]