输入：
一个整数列表/数组，其每个项目都在的范围内2-36。

输出：
整数的总和（以10为底），其中每个下一个整数均以上一个值的底数（以常规的10开头）。

示例：
假设我们有一个这样的输入：[4, 12, 34, 20, 14, 6, 25, 13, 33]
然后我们有一个这样的总和：

4    (4  in base-10) +
6    (12 in base-4 ) +
40   (34 in base-12) +
68   (20 in base-34) +
24   (14 in base-20) +
6    (6  in base-14) +
17   (25 in base-6 ) +
28   (13 in base-26) +
42   (33 in base-13)
= 235

数学基数解释：
我考虑过假设每个人都知道基数是如何工作的，但是为了以防万一，我将举一个简单的例子说明其如何工作。让我们34 in base-12举个例子，我们如何得到的40？

1-34 in regular base-10:
 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34
 So, from 1 to 34 is 34 steps in base-10

1-34 in base-12:
 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 1A, 1B, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 2A, 2B, 30, 31, 32, 33, 34
 So, from 1 to 34 is 40 steps in base-12

这也许是一个有用的计算器。

挑战规则：

• 数组大小将在合理范围内（例如1-100/参见测试用例）。
• 测试用例将永远不会包含其当前值对其前一个基数无效的整数（即，您永远不会有19 in base-6或6 in base-6，因为基数6仅包含数字0-5）。
• 您可以根据需要选择输入内容。可以作为整数数组，也可以作为逗号/空格分隔的字符串，等等。您的呼叫。（您也可以反转int数组，这对基于堆栈的编程语言可能很有用。）

一般规则：

• 这是代码高尔夫球，因此最短答案以字节为单位。
  不要让代码高尔夫语言阻止您使用非高尔夫语言发布答案。尝试针对任何编程语言提出尽可能短的答案。
• 标准规则适用于您的答案，因此允许您使用STDIN / STDOUT，具有适当参数的函数/方法，完整程序。你的来电。
• 默认漏洞是禁止的。
• 如果可能的话，请添加一个带有测试代码的链接。
• 另外，如有必要，请添加说明。

测试用例：

[4, 12, 34, 20, 14, 6, 25, 13, 33]                            ->   235
 4+ 6+  40+ 68+ 24+ 6+ 17+ 28+ 42

[5, 14, 2, 11, 30, 18]                                        ->   90
 5+ 9+  2+ 3+  33+ 38

[12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 12, 2, 11, 3, 10, 2, 10]    ->   98
 12+ 13+ 11+ 9+ 8+ 7+ 6+ 5+ 4+ 3+ 5+  2+ 3+  3+ 3+  2+ 2

[36, 36]                                                      ->   150
 36+ 114

05AB1E，7 6 5字节

使用05AB1E编码。

使用凯文·克鲁伊森š（Kevin Cruijssen）建议的新内置方法节省了1个字节

TšüöO

说明

根据质询规范，输入列表取反。

Tš     # prepend a 10 to the list
  üö   # reduce by conversion to base-10
    O  # sum

在线尝试！

改良的测试套件

Python 3，40个字节

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

测试在ideone

map(str, a)创建一个生成器，该生成器G调用转换中的字符串中的str每个值创建一个生成器，该生成器调用跨对并转换整数基中的字符串（如果在且有效）按照锡上的说明进行操作a
map(int, G, [10]+a)int(g, v)G[10]+a
int(g, v)gvv[2,36]g
sum

Python 2，48个字节

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

测试在ideone

zip(a,[10]+a)遍历对在值a，且前值或10第一个
的backticks在int调用转换x为字符串，s
int(s, y)将字符串转换s从整数基地y（如果y是在[2,36]和s有效）
sum做什么它在锡说

Perl，35 34 33字节

包括+2 -ap

使用STDIN上的数字列表运行：

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

basemix.pl：

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

我一直在等待机会来使用这种滥用方式...

说明

输入的数字最多可以有2位数字。许多xy在碱b是简单地b*x+y。我将使用正则表达式，/.$/因此第一个数字以结尾，$`最后一个数字为结尾$&，因此对总和的贡献为$&+$b*$`。

我滥用这样一个事实，即for不能正确地对正则表达式变量进行本地化（例如，例如map和whiledo），因此前一个循环中的匹配结果在当前循环中仍然可用。因此，如果我对执行操作的顺序感到谨慎"$`$&"，则除了第一个需要将基数为10的循环外，基数可用为，所以我"$`$& 10"改用

第一次$&工作的方式也是一种滥用，因为实际上/.$/它已经在等待添加的堆栈上更改了。

最后的滥用是}{在这改变隐含了循环的结束-p，从

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

至

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

这意味着$_在打印中将是未定义的，但仍然会$\在其中累加总和。这也是获得后循环处理的标准高尔夫技巧

PHP，53 51字节

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

遍历输入，将每个输入转换为字符串变体。然后使用以前一个数字为基数的整数值。对于第一个数字，将不设置基数，然后PHP将以10（从数字格式推断）开始。

像这样运行（-d仅出于美观目的而添加）：

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

调整

• 实际上，不需要转换为字符串，因为CLI参数已经是字符串了。保存了2个字节。

果冻，7个字节

ṙ1DḅṖḌS

在线尝试！

Java，86个字节

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

测试和取消高尔夫

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字节

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

方便地parseInt(x,0) === parseInt(x,10)。

编辑：由于@ETHproductions，节省了1个字节

纯扑，38

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

输入列表在命令行中给出。 for i;自动迭代输入参数（等效于for i in $@;）。

伊迪恩

Java 7，109 89 86字节

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

感谢@cliffroot（由于我自己犯了一个愚蠢的错误，其中有12 个字节）赢得了20个字节。

取消测试的代码：

在这里尝试。

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 }));
  }
}

输出：

235
90
98
150

其实是12个位元组

;p(dX(♂$♀¿Σ+

在线尝试！

说明：

;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个字节

l~{A\:A10bb}%:+

在线尝试！

说明

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字节

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

在Ideone上进行测试。

Matlab，68个字节

这不是一个非常有创意的解决方案，但是这里是：

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

测试：

>> 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字节

我使用了递归方法。

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

感谢Lmis，节省了6个字节！
多亏了尼尔，节省了8个字节！

Perl 6的， 52  50个字节

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

说明：

# 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字节

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

在Ideone上进行测试。

朱莉娅63字节

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

解析每个数字（第一个数字除外），以前一个元素为基数和求和。在末尾添加第一个元素

Ruby，52个字节

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

不打高尔夫球

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

用法

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个字节

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

说明：

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个字节

我希望Mathematica的函数名称短一些。但是，否则我很高兴。

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

例如，

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

产量235。

{##,0}是输入自变量的列表，后跟0（代表数字）；{10,##}是带有10个前缀（表示基数）的输入参数的列表。该对列表是Transposed，以将每个数字与它的基数相关联，并且FromDigits（yay！）将每个数字-基数对转换为10以底的整数，其结果由求和Tr。

常见的Lisp，83

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

细节

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

该loop构造接受“V则w”迭代构造，其中v是第一次计算迭代变量时要评估的表达式，而w是要为连续迭代评估的表达式。声明的求值是一个接一个的，因此base首先是“ 10”，然后string是列表的前一个元素list。所述sum关键字计算一个总和：整数读取string用碱b，其中b是从所述解析的整数base串，在底座10 #1=和#1#是符号定义和使用读取器变量：第一个影响变量的s表达式，另一个则用同一对象替换引用。这样可以为长名保存一些字符。

例

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

Japt -x，7个字节

äÏsnX}A

试试吧

äÏ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