Python 3, 40 bytes

lambda a:sum(map(int,map(str,a),[10]+a)) 

Tests are at ideone

map(str, a) creates a generator, G, that calls str on each value in a, converting to strings
map(int, G, [10]+a) creates a generator that calls int(g, v) for pairs across G and [10]+a
int(g, v) converts the string g from the integer base v (if v is in [2,36] and g is valid)
sum does what it says on the tin

Python 2, 48 bytes

lambda a:sum(int(`x`,y)for x,y in zip(a,[10]+a)) 

Tests are at ideone

zip(a,[10]+a) traverses pairs of the values in a, and the previous value or 10 for the first
the backticks in the int call convert x to a string, s
int(s, y) converts the string s from the integer base y (if y is in [2,36] and s is valid)
sum does what it says on the tin

Perl, 35 34 33 bytes

Includes +2 for -ap

Run with the list of numbers on STDIN:

basemix.pl <<< "4 12 34 20 14 6 25 13 33";echo 

basemix.pl:

#!/usr/bin/perl -ap $\+=$&+"$`$& 10"*/.$/*$`for@F}{ 

I've been waiting for ages for a chance to use this abuse...

Explanation

The input numbers can have at most 2 digits. A number xy in base b is simply b*x+y. I'm going to use the regex /.$/ so the first digit ends up in $` and the last digit in $&, so the contribution to the sum is $&+$b*$`.

I abuse the fact that for does not properly localize the regex variables (like for example map and while do) so the results of a match in the previous loop is still available in the current loop. So if I'm careful about the order in which I do the operations the base is available as "$`$&", except for the very first loop where I need the base to be 10. So I use "$`$& 10" instead

The way the first $& works is an abuse too since it is actually changed by the /.$/ while it is already on the stack waiting to be added.

The final abuse is the }{ at the end which changes the loop implied by -p from

LINE: while (defined($_ = <ARGV>)) { ...code.. } continue { die "-p destination: $!\n" unless print $_; } 

to

LINE: while (defined($_ = <ARGV>)) { ...code.. } { } continue { die "-p destination: $!\n" unless print $_; } 

Which means $_ will be undefined in the print, but it still adds $\ in which I accumulated the sum. It is also a standard golf trick to get post-loop processing

PHP, 53 51 bytes

for(;$x=$argv[++$i];$b=$x)$s+=intval($x,$b);echo$s; 

Iterates over the input, converting each input to string variant. Then takes the integer value using the previous number as base. For the first number, the base will not be set, PHP will then start off with 10 (inferred from the number format).

Run like this (-d added for aesthetics only):

php -d error_reporting=30709 -r 'for(;$x=$argv[++$i];$b=$x)$s+=intval($x,$b);echo$s;' -- 12 11 10 9 8 7 6 5 4 3 12 2 11 3 10 2 10;echo 

Tweaks

• Actually, no need to convert to string, as CLI arguments are already string. Saved 2 bytes.

Jelly, 7 bytes

ṙ1DḅṖḌS 

Try it online!

Java, 86 bytes

s->{int[]b={10};return s.reduce(0,(r,n)->{r+=n.valueOf(""+n,b[0]);b[0]=n;return r;});} 

Testing and ungolfed

import java.util.function.ToIntFunction; import java.util.stream.Stream; public class Main { public static void main(String[] args) { ToIntFunction<Stream<Integer>> f = s -> { int[] b = {10}; // Base, initialized with 10 return s.reduce(0, (r, n) -> { // Typical use of reduction, sum starts with 0. r += n.valueOf("" + n, b[0]); // Add the value in the previous base. b[0] = n; // Assign the new base; return r; }); }; System.out.println(f.applyAsInt(Stream.of(new Integer[]{4, 12, 34, 20, 14, 6, 25, 13, 33}))); } } 

JavaScript ES6, 45 42 41 Bytes

const g = a=>a.map(v=>s+=parseInt(v,p,p=v),s=p=0)|s ; console.log(g.toString().length); // 42 console.log(g([4, 12, 34, 20, 14, 6, 25, 13, 33])); // 235 console.log(g([5, 14, 2, 11, 30, 18] )); // 90 console.log(g([12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 12, 2, 11, 3, 10, 2, 10] )); // 98

Conventiently parseInt(x,0) === parseInt(x,10).

edit: Saved 1 byte thanks to @ETHproductions

Pure bash, 38

b=10 for i;{((t+=$b#$i,b=i));} echo $t 

The input list is given at the command-line. for i; automatically iterates over the input parameters (equivalent to for i in $@;).

Ideone.

Java 7, 109 89 86 bytes

int c(int[]a){for(Byte i=1;i<a.length;a[0]+=i.valueOf(a[i]+"",a[++i-2]));return a[0];} 

Golfed 20 bytes thanks to @cliffroot (of which 12 because of a stupid mistake I made myself).

Ungolfed & test code:

Try it here.

class M{ static int c(int[] a){ for(Byte i = 1; i < a.length; a[0] += i.valueOf(a[i]+"", a[++i-2])); return a[0]; } public static void main(String[] a){ System.out.println(c(new int[]{ 4, 12, 34, 20, 14, 6, 25, 13, 33 })); System.out.println(c(new int[]{ 5, 14, 2, 11, 30, 18 })); System.out.println(c(new int[]{ 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 12, 2, 11, 3, 10, 2, 10 })); System.out.println(c(new int[]{ 36, 36 })); } } 

Output:

235 90 98 150 

Actually, 12 bytes

;p(dX(♂$♀¿Σ+ 

Try it online!

Explanation:

;p(dX(♂$♀¿Σ+ ; dupe input p pop first element from list (dX pop and discard last element from other copy (♂$ stringify all elements in first copy ♀¿ for each pair of elements in the two lists, interpret the first element as a base-(second element) integer Σ sum + add first element of original list 

CJam, 15 bytes

l~{A\:A10bb}%:+ 

Try it online!

Explanation

l~ e# Read and evaluate input. { e# Map this block over the input... A e# Push A. Initially this is 10, afterwards it will be the value of the e# last iteration. \:A e# Swap with current value and store that in A for the next iteration. 10b e# Convert to base 10 to get its decimal digits. b e# Interpret those in the base of the previous A. }% :+ e# Sum all of those values. 

Haskell, 65 59 bytes

b%x|x<1=x|y<-div x 10=b*b%y+x-10*y sum.((10:)>>=zipWith(%)) 

Test it on Ideone.

Matlab, 68 bytes

Not a very creative solution, but here it is:

function[s]=r(x);j=10;s=0;for(i=x)s=s+base2dec(num2str(i),j);j=i;end 

Tests:

>> r([4,12,34,20,14,6,25,13,33]) ans = 235 >> r([12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 12, 2, 11, 3, 10, 2, 10]) ans = 98 >> r([5, 14, 2, 11, 30, 18]) ans = 90 >> r([36,36]) ans = 150 

JavaScript (ES6), 54 48 40 bytes

I used a recursive approach.

f=([b,...a],c)=>b?parseInt(b,c)+f(a,b):0 

Saved 6 bytes, thanks to Lmis!
Saved 8 more bytes, thanks to Neil!

Perl 6,  52  50 bytes

{sum (10,|@_).rotor(2=>-1).map:{+":{.[0]}<{.[1]}>"}} {sum (10,|@_).rotor(2=>-1).map:{":{.[0]}<$_[1]>"}} 

Explanation:

# bare block lambda with implicit parameter ｢@_｣ { sum ( 10, |@_ ) # the input with a preceding 10 .rotor( 2 => -1 ) # grab 2 values, back up one, repeat .map: { # create a string of the form ":10<4>" ":{ .[0] # first element from $_ }<{ .[1] # second element from $_ }>" } } 

Python 2, 52 bytes

f=lambda x:x[1:]and int(`x.pop()`,x[-1])+f(x)or x[0] 

Test it on Ideone.

Julia, 63 Bytes

f(l)=sum([parse(Int,string(l[i]),l[i-1])for i=2:length(l)])+l[] 

Parses each number (except the first) taking the previous element as base and sums. Adds the first element at the end

Ruby, 52 bytes

->a{eval a.zip([10]+a).map{|e|'"%s".to_i(%s)'%e}*?+} 

ungolfed

->a{ eval( a.zip([10]+a).map { |e| '"%s".to_i(%s)' % e }.join("+") ) } 

usage

f=->a{eval a.zip([10]+a).map{|e|'"%s".to_i(%s)'%e}*?+} p f[[4, 12, 34, 20, 14, 6, 25, 13, 33]] # => 235 

Scala, 67 bytes

def f(a:Int*)=a zip(10+:a)map{t=>Integer.parseInt(""+t._1,t._2)}sum 

Explanation:

def f(a: Int*) = //declare a method f with varargs of type Int as parameter a zip (10 +: a) //zip a with 10 prepended to a, resulting in... //...Array((4,10), (12,4), (34,12), (20,34), (14,20), (6,14), (25,6), (13,25), (33,13)) map { t => //map each tuple t to... Integer.parseInt( //...an integer by parsing... ""+t._1, t._2 //...a string of the first item in base-second-item. ) } sum //and sum 

Mathematica, 59 bytes

I wish Mathematica's function names were shorter. But otherwise I'm happy.

Tr[FromDigits@@@Transpose@{IntegerDigits/@{##,0},{10,##}}]& 

For example,

Tr[FromDigits@@@Transpose@{IntegerDigits/@{##,0},{10,##}}]&[4,12,34,20,14,6,25,13,33] 

yields 235.

{##,0} is a list of the input arguments with 0 appended (representing the numerals); {10,##} is a list of the input arguments with 10 prepended (representing the bases). That pair of lists is Transposed to associate each with numeral with its base, and FromDigits (yay!) converts each numeral-base pair to a base-10 integer, the results of which are summed by Tr.

Common Lisp, 83

(lambda(s)(loop for b ="10"then x for x in s sum(#1=parse-integer x :radix(#1#b)))) 

Details

(defun base-mix (list) (loop for base = "10" then string for string in list sum (parse-integer string :radix (parse-integer base)))) 

The loop construct accepts "v then w" iteration constructs, where v is an expression to be evaluated the first time the iteration variable is computed, and w is the expression to be evaluated for the successive iterations. Declarations are evaluated one after the other, so base is first "10", then the previous element stringof the list list being iterated. The sum keyword computes a sum: the integer read from string with base b, where b is the integer parsed from the base string, in base 10. #1= and #1# are notations to define and use reader variables: the first affects an s-expression to a variable, the other one replaces the reference by the same object. This saves some characters for long names.

Example

(base-mix '("4" "12" "34" "20" "14" "6" "25" "13" "33")) => 235 

Japt -x, 7 bytes

äÏsnX}A 

Try it

äÏsnX}A :Implicit input of array ä :Take each consecutive pair of elements Ï :Pass them through the following function as X & Y s : Convert Y to a base-10 string nX : Convert to an integer from base-X } :End function A :Before doing any of that, though, prepend 10 to the array :Implicit output of the sum of the resulting array