Input:
un elenco / array di numeri interi per i quali ciascun elemento è compreso nell'intervallo di 2-36.

Output:
la somma degli interi (come base 10), in cui ogni intero successivo è nella base del valore precedente (a partire da una base 10 normale).

Esempio:
supponiamo di avere un input come questo: [4, 12, 34, 20, 14, 6, 25, 13, 33]
Quindi abbiamo una somma come questa:

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

Spiegazione della base matematica:
ho considerato di presumere che tutti sappiano come funziona la base, ma darò un breve esempio di come funziona comunque, per ogni evenienza. Prendiamo34 in base-12ad esempio, come siamo arrivati40?

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

Ecco forse un calcolatore utile.

Regole della sfida:

• Le dimensioni dell'array saranno entro un intervallo ragionevole (come 1-100/ vedi casi di test).
• I casi di test non conterranno mai numeri interi di cui il valore corrente non è valido per la sua base precedente (cioè non avrai mai qualcosa di simile 19 in base-6o 6 in base-6, poiché base-6 contiene solo le cifre 0-5).
• Puoi prendere l'input come preferisci. Può essere una matrice int, una stringa separata da virgola / spazio, ecc. La tua chiamata. (È anche consentito invertire l'int-array, il che potrebbe essere utile per linguaggi di programmazione basati su stack.)

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non permettere alle lingue di golf di codice di scoraggiarti dal pubblicare risposte con lingue non di golf. Prova a trovare una risposta il più breve possibile per qualsiasi linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

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

Utilizza la codifica 05AB1E .

Salvato 1 byte usando il nuovo built-in šcome suggerito da Kevin Cruijssen

TšüöO

Spiegazione

L'elenco di input viene preso invertito, come consentito dalle specifiche della sfida.

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

Provalo online!

Test suite modificato

Python 3, 40 byte

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

I test sono su ideone

map(str, a)crea un generatore, Gche chiama strogni valore in a, convertendolo in stringhe
map(int, G, [10]+a)crea un generatore che chiama int(g, v)coppie attraverso Ge [10]+a
int(g, v)converte la stringa gdalla base intera v(se vè dentro [2,36]ed gè valida)
sumfa quello che dice sulla tin

Python 2, 48 byte

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

I test sono su ideone

zip(a,[10]+a)attraversa coppie di valori a, e il valore precedente o 10per il primo
la backticksnella intchiamata convertito xin una stringa, s
int(s, y)converte la stringa sdalla base intero y(se yè in [2,36]ed sè valido)
sumfa quello che promette

Perl, 35 34 33 byte

Include +2 per -ap

Esegui con l'elenco di numeri su STDIN:

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

basemix.pl:

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

Sto aspettando da anni la possibilità di usare questo abuso ...

Spiegazione

I numeri di input possono avere al massimo 2 cifre. Un numero xyin base bè semplicemente b*x+y. Userò il regex in /.$/modo che la prima cifra finisca in $`e l'ultima cifra in $&, quindi il contributo alla somma è $&+$b*$`.

Abuso del fatto che fornon localizzi correttamente le variabili regex (come ad esempio mape whilefare), quindi i risultati di una corrispondenza nel ciclo precedente sono ancora disponibili nel ciclo corrente. Quindi, se faccio attenzione all'ordine in cui eseguo le operazioni, la base è disponibile come "$`$&", ad eccezione del primo ciclo in cui ho bisogno che la base sia 10. Quindi uso "$`$& 10"invece

Anche il modo in cui funziona il primo $&è un abuso poiché è effettivamente cambiato dal /.$/momento che è già nello stack in attesa di essere aggiunto.

L'abuso finale è }{l'all'estremità che cambia il loop implicito -pda

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 $_;
}

Il che significa $_che non sarà definito nella stampa, ma aggiunge ancora $\in cui ho accumulato la somma. È anche un trucco da golf standard per ottenere l'elaborazione post-loop

PHP, 53 51 byte

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

Scorre sull'input, convertendo ogni input in variante stringa. Quindi accetta il valore intero utilizzando il numero precedente come base. Per il primo numero, la base non verrà impostata, PHP inizierà quindi con 10 (dedotto dal formato numerico).

Esegui in questo modo ( -daggiunto solo per l'estetica):

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

Ritocchi

• In realtà, non è necessario convertire in stringa, poiché gli argomenti CLI sono già stringa. Salvato 2 byte.

Gelatina , 7 byte

ṙ1DḅṖḌS

Provalo online!

Java, 86 byte

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

Test e 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 byte

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

Per caso parseInt(x,0) === parseInt(x,10).

modifica : salvato 1 byte grazie a @ETHproductions

Bash puro, 38

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

L'elenco di input è indicato nella riga di comando. for i;scorre automaticamente i parametri di input (equivalenti a for i in $@;).

Ideone.

Java 7, 109 89 86 byte

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

Giocato a golf 20 byte grazie a @cliffroot (di cui 12 a causa di uno stupido errore che ho commesso).

Codice non testato e test:

Provalo qui.

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

Produzione:

235
90
98
150

In realtà, 12 byte

;p(dX(♂$♀¿Σ+

Provalo online!

Spiegazione:

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

l~{A\:A10bb}%:+

Provalo online!

Spiegazione

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 byte

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

Provalo su Ideone .

Matlab, 68 byte

Non è una soluzione molto creativa, ma eccola qui:

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

test:

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

Ho usato un approccio ricorsivo.

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

6 byte salvati, grazie a Lmis!
Risparmiato altri 8 byte, grazie a Neil!

Perl 6 ,  52  50 byte

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

Spiegazione:

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

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

Provalo su Ideone .

Julia, 63 byte

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

Analizza ogni numero (tranne il primo) prendendo l'elemento precedente come base e somma. Aggiunge il primo elemento alla fine

Rubino, 52 byte

->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("+")
  )
}

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 byte

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

Spiegazione:

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 byte

Vorrei che i nomi delle funzioni di Mathematica fossero più brevi. Ma per il resto sono felice.

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

Per esempio,

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

rese 235.

{##,0}è un elenco degli argomenti di input con 0 aggiunto (che rappresenta i numeri); {10,##}è un elenco degli argomenti di input con 10 anteposti (che rappresentano le basi). Quella coppia di liste è Transposed per associare ciascuna a un numero con la sua base, e FromDigits(yay!) Converte ogni coppia base-numerale in un intero di base-10, i cui risultati sono sommati da Tr.

Lisp comune, 83

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

Dettagli

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

Il loopcostrutto accetta costrutti di iterazione "v then w" , dove v è un'espressione da valutare la prima volta che viene calcolata la variabile di iterazione e w è l'espressione da valutare per le iterazioni successive. Dichiarazioni vengono valutati uno dopo l'altro, così baseè prima "10", l'elemento precedente stringdell'elenco listessere iterati. La sumparola chiave calcola una somma: il numero intero letto dalla stringbase b , dove b è il numero intero analizzato dalla basestringa, nella base 10. #1=e #1#sono notazioni per definire e utilizzare le variabili del lettore: il primo influenza un'espressione s su una variabile, l'altro sostituisce il riferimento con lo stesso oggetto. Questo salva alcuni personaggi per nomi lunghi.

Esempio

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

Japt -x , 7 byte

äÏsnX}A

Provalo

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