Entrada:
una lista / matriz de enteros para los que cada elemento está en el rango de 2-36.

Salida:
La suma de los enteros (como base 10), donde cada entero siguiente está en la base del valor anterior (comenzando con una base regular 10).

Ejemplo:
Digamos que tenemos una entrada como esta: [4, 12, 34, 20, 14, 6, 25, 13, 33]
Luego tenemos una suma como esta:

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

Explicación de la base matemática:
consideré asumir que todos saben cómo funciona la base, pero de todos modos daré un breve ejemplo de cómo funciona, por si acaso. Tomemos34 in base-12por ejemplo, ¿cómo llegamos40?

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

Aquí hay quizás una calculadora útil.

Reglas de desafío:

• El tamaño de la matriz estará en un rango razonable (como 1-100/ ver casos de prueba).
• Los casos de prueba nunca contendrán números enteros cuyo valor actual no sea válido para su base anterior (es decir, nunca tendrá algo como 19 in base-6o 6 in base-6, porque base-6 solo contiene los dígitos 0-5).
• Puede tomar la entrada de la forma que desee. Puede ser como una matriz de int, como una cadena separada por comas / espacios, etc. Su llamada. (También se le permite tomar la matriz int invertida, lo que podría ser útil para los lenguajes de programación basados ​​en pila).

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los idiomas de código de golf lo desanimen a publicar respuestas con idiomas que no sean de golf. Trate de encontrar una respuesta lo más breve posible para cualquier lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados, programas completos. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, agregue una explicación si es necesario.

Casos de prueba:

[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 bytes

Utiliza la codificación 05AB1E .

Se guardó 1 byte usando el nuevo incorporado šcomo lo sugiere Kevin Cruijssen

TšüöO

Explicación

La lista de entrada se invierte, según lo permitido por la especificación de desafío.

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

Pruébalo en línea!

Conjunto de pruebas modificado

Python 3, 40 bytes

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

Las pruebas están en ideone

map(str, a)crea un generador, Gque llama stra cada valor a, la conversión a cadenas
map(int, G, [10]+a)crea un generador que llama int(g, v)a pares Gy [10]+a
int(g, v)convierte la cadena gde la base entera v(si vestá dentro [2,36]y ges válida)
sumhace lo que dice en la lata

Python 2, 48 bytes

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

Las pruebas están en ideone

zip(a,[10]+a)atraviesa pares de los valores de a, y el valor anterior o 10para el primero
el backticksen el intconvert llamada xa una cadena, s
int(s, y)convierte la cadena sde la base de número entero y(si yes en [2,36]y ses válido)
sumhace lo que dice en la lata

Perl, 35 34 33 bytes

Incluye +2 para -ap

Ejecute con la lista de números en STDIN:

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

basemix.pl:

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

He estado esperando por años la oportunidad de usar este abuso ...

Explicación

Los números de entrada pueden tener como máximo 2 dígitos. Un número xyen base bes simplemente b*x+y. Voy a usar la expresión regular /.$/para que el primer dígito termine $`y el último dígito $&, así que la contribución a la suma es $&+$b*$`.

Abuso del hecho de que forno localiza correctamente las variables regex (como por ejemplo mapy whiledo), por lo que los resultados de una coincidencia en el bucle anterior todavía están disponibles en el bucle actual. Entonces, si tengo cuidado con el orden en el que hago las operaciones, la base está disponible "$`$&", excepto por el primer bucle donde necesito que la base sea 10. Entonces uso "$`$& 10"en su lugar

La forma en que funciona el primero también $&es un abuso, ya que en realidad se cambia /.$/mientras ya está en la pila esperando ser agregado.

El abuso final es el }{final que cambia el bucle implícito -pde

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

a

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

Lo que significa $_que no estará definido en la impresión, pero aún agrega $\en el que acumulé la suma. También es un truco de golf estándar para obtener el procesamiento posterior al bucle.

PHP, 53 51 bytes

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

Itera sobre la entrada, convirtiendo cada entrada a la variante de cadena. Luego toma el valor entero usando el número anterior como base. Para el primer número, no se establecerá la base, PHP comenzará con 10 (inferido del formato de número).

Ejecutar así ( -dagregado solo por estética):

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

Ajustes

• En realidad, no es necesario convertir a cadena, ya que los argumentos de la CLI ya son cadenas. Guardado 2 bytes.

Jalea , 7 bytes

ṙ1DḅṖḌS

Pruébalo en línea!

Java, 86 bytes

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

Prueba y sin golf

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).

editar : guardado 1 byte gracias a @ETHproductions

Puro golpe, 38

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

La lista de entrada se da en la línea de comandos. for i;itera automáticamente sobre los parámetros de entrada (equivalente a for i in $@;).

Ideona

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

Golfé 20 bytes gracias a @cliffroot (de los cuales 12 por un estúpido error que cometí).

Ungolfed y código de prueba:

Pruébalo aquí

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

Salida:

235
90
98
150

En realidad, 12 bytes

;p(dX(♂$♀¿Σ+

Pruébalo en línea!

Explicación:

;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}%:+

Pruébalo en línea!

Explicación

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(%))

Pruébalo en Ideone .

Matlab, 68 bytes

No es una solución muy creativa, pero aquí está:

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

Pruebas:

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

Usé un enfoque recursivo.

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

Guardado 6 bytes, gracias a Lmis!
¡Ahorré 8 bytes más, gracias a Neil!

Perl 6 ,  52  50 bytes

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

Explicación:

# 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]

Pruébalo en Ideone .

Julia, 63 bytes

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

Analiza cada número (excepto el primero) tomando el elemento anterior como base y sumas. Agrega el primer elemento al final

Ruby, 52 bytes

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

sin golf

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

uso

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

Explicación:

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

Desearía que los nombres de las funciones de Mathematica fueran más cortos. Pero por lo demás estoy feliz.

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

Por ejemplo,

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

rendimientos 235.

{##,0}es una lista de los argumentos de entrada con 0 agregado (que representa los números); {10,##}es una lista de los argumentos de entrada con 10 antepuestos (que representan las bases). Ese par de listas es Transposed para asociar cada una con un número con su base, y FromDigits(¡sí!) Convierte cada par numeral-base en un entero de base 10, cuyos resultados se suman por Tr.

Lisp común, 83

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

Detalles

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

La loopconstrucción acepta construcciones de iteración "v luego w" , donde v es una expresión que se evaluará la primera vez que se calcula la variable de iteración, y w es la expresión que se evaluará para las iteraciones sucesivas. Las declaraciones se evalúan una tras otra, por baselo que primero se "10", luego se itera el elemento anterior stringde la lista list. La sumpalabra clave calcula una suma: el entero leído desde la stringbase b , donde b es el entero analizado desde la basecadena, en la base 10. #1=y#1# son anotaciones para definir y usar variables de lector: el primero afecta una expresión s a una variable, el otro reemplaza la referencia por el mismo objeto. Esto guarda algunos caracteres para nombres largos.

Ejemplo

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

Japt -x , 7 bytes

äÏsnX}A

Intentalo

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