Entrée:
Une liste / tableau d'entiers pour lesquels chaque élément est dans la plage de 2-36.

Sortie:
La somme des entiers (en base 10), où chaque entier suivant est dans la base de la valeur précédente (en commençant par une base régulière 10).

Exemple:
Disons que nous avons une entrée comme celle-ci: [4, 12, 34, 20, 14, 6, 25, 13, 33]
Ensuite, nous avons une somme comme celle-ci:

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

Base mathématique expliquée:
J'ai considéré que tout le monde sait comment fonctionne la base, mais je vais quand même donner un bref exemple de la façon dont cela fonctionne, juste au cas où. Prenons l'34 in base-12exemple, comment avons-nous obtenu40?

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

Voici peut-être une calculatrice utile.

Règles du défi:

• La taille du tableau sera dans une plage raisonnable (comme 1-100/ voir les cas de test).
• Les cas de test ne contiendront jamais d'entiers dont la valeur actuelle n'est pas valide pour sa base précédente (c'est-à-dire que vous n'aurez jamais quelque chose comme 19 in base-6ou 6 in base-6, car la base-6 ne contient que les chiffres 0-5).
• Vous pouvez prendre l'entrée comme vous le souhaitez. Peut être un tableau int, une chaîne séparée par des virgules / espaces, etc. Votre appel. (Vous pouvez également inverser l'int-array, ce qui pourrait être utile pour les langages de programmation basés sur la pile.)

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf. Essayez de trouver une réponse aussi courte que possible pour n'importe quel langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés, des programmes complets. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

Cas de test:

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

Utilise l' encodage 05AB1E .

1 octet enregistré en utilisant le nouveau intégré šcomme suggéré par Kevin Cruijssen

TšüöO

Explication

La liste d'entrée est inversée, comme le permet la spécification de défi.

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

Essayez-le en ligne!

Suite de tests modifiée

Python 3, 40 octets

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

Les tests sont à l' idéone

map(str, a)crée un générateur, Gqui appelle strchaque valeur dans a, la conversion en chaînes
map(int, G, [10]+a)crée un générateur qui appelle int(g, v)des paires à travers Get [10]+a
int(g, v)convertit la chaîne à gpartir de la base entière v(si elle vest [2,36]et gest valide)
sumfait ce qu'elle dit sur l'étain

Python 2, 48 octets

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

Les tests sont à l' idéone

zip(a,[10]+a)traverse des paires de valeurs dans a, et la valeur précédente ou 10pour la première,
l' appel backticksdans la intconversion xen chaîne, s
int(s, y)convertit la chaîne à spartir de la base entière y(si elle yest dans [2,36]et sest valide)
sumfait ce qu'elle dit sur l'étain

Perl, 35 34 33 octets

Comprend +2 pour -ap

Exécutez avec la liste des numéros sur STDIN:

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

basemix.pl:

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

J'attends depuis des lustres une chance d'utiliser cet abus ...

Explication

Les numéros saisis peuvent avoir au plus 2 chiffres. Un nombre xyen base best tout simplement b*x+y. Je vais utiliser l'expression régulière /.$/pour que le premier chiffre se termine $`et le dernier chiffre $&, donc la contribution à la somme est $&+$b*$`.

J'abuse du fait que forne localise pas correctement les variables regex (comme par exemple mapet whiledo) donc les résultats d'une correspondance dans la boucle précédente sont toujours disponibles dans la boucle actuelle. Donc, si je fais attention à l'ordre dans lequel je fais les opérations, la base est disponible "$`$&", sauf pour la toute première boucle où j'ai besoin que la base soit de 10. Donc j'utilise à la "$`$& 10"place

La façon dont le premier $&fonctionne est également un abus car il est en fait modifié /.$/pendant qu'il est déjà sur la pile en attente d'être ajouté.

L'abus final est le }{à la fin qui change la boucle impliquée par -pde

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

à

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

Ce qui $_ne sera pas défini dans l'impression, mais cela ajoute $\quand même que j'ai accumulé la somme. C'est aussi une astuce de golf standard pour obtenir un traitement post-boucle

PHP, 53 51 octets

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

Itère sur l'entrée, convertissant chaque entrée en variante de chaîne. Prend ensuite la valeur entière en utilisant le nombre précédent comme base. Pour le premier nombre, la base ne sera pas définie, PHP commencera alors avec 10 (déduit du format numérique).

Courez comme ceci ( -dajouté pour l'esthétique uniquement):

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

• En fait, pas besoin de convertir en chaîne, car les arguments CLI sont déjà des chaînes. Enregistré 2 octets.

Gelée , 7 octets

ṙ1DḅṖḌS

Essayez-le en ligne!

Java, 86 octets

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

Test et non 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 octets

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

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

edit : 1 octet enregistré grâce à @ETHproductions

Pure bash, 38

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

La liste d'entrée est donnée sur la ligne de commande. for i;itère automatiquement les paramètres d'entrée (équivalent à for i in $@;).

Ideone.

Java 7, 109 89 86 octets

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 octets grâce à @cliffroot (dont 12 à cause d'une stupide erreur que j'ai faite moi-même).

Code non testé et testé:

Essayez-le ici.

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

Sortie:

235
90
98
150

En fait, 12 octets

;p(dX(♂$♀¿Σ+

Essayez-le en ligne!

Explication:

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

l~{A\:A10bb}%:+

Essayez-le en ligne!

Explication

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 octets

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

Testez-le sur Ideone .

Matlab, 68 octets

Pas une solution très créative, mais la voici:

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 octets

J'ai utilisé une approche récursive.

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

6 octets enregistrés grâce à Lmis!
8 octets de plus enregistrés, grâce à Neil!

Perl 6 ,  52  50 octets

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

Explication:

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

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

Testez-le sur Ideone .

Julia, 63 octets

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

Analyse chaque nombre (sauf le premier) en prenant l'élément précédent comme base et somme. Ajoute le premier élément à la fin

Rubis, 52 octets

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

non golfé

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

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

Explication:

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 octets

Je souhaite que les noms de fonction de Mathematica soient plus courts. Mais sinon je suis content.

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

Par exemple,

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

rendements 235.

{##,0}est une liste des arguments d'entrée avec 0 ajouté (représentant les chiffres); {10,##}est une liste des arguments d'entrée avec 10 préfixés (représentant les bases). Cette paire de listes est Transposed à associer chacune avec un chiffre à sa base, et FromDigits(ouais!) Convertit chaque paire de base numérique en un entier de base 10, dont les résultats sont additionnés par Tr.

Lisp commun, 83

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

Détails

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

La loopconstruction accepte les constructions d' itération "v puis w" , où v est une expression à évaluer la première fois que la variable d'itération est calculée et w est l'expression à évaluer pour les itérations successives. Les déclarations sont évaluées les unes après les autres, tout basecomme "10", puis l'élément précédent stringde la liste listest itéré. Le summot clé calcule une somme: l'entier lu stringavec la base b , où b est l'entier analysé à partir de la basechaîne, en base 10. #1=et #1#sont des notations pour définir et utiliser des variables de lecteur: le premier affecte une expression s à une variable, l'autre remplace la référence par le même objet. Cela enregistre certains caractères pour les noms longs.

Exemple

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

Japt -x , 7 octets

äÏsnX}A

Essayez-le

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