입력 :
각 항목이의 범위에있는 정수 목록 / 배열입니다 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: 테스트 사례 참조).
• 테스트 케이스에는 현재 값이 이전 기준에 대해 유효하지 않은 정수가 포함되지 않습니다 (즉 , base-6 만 포함하기 때문에 19 in base-6or 와 같은 것을 가질 수 없습니다 ).6 in base-60-5
• 원하는 방식으로 입력 할 수 있습니다. int-array, 쉼표 / ​​공백으로 구분 된 문자열 등이 될 수 있습니다. (또한 int-array를 뒤집을 수 있으며, 이는 스택 기반 프로그래밍 언어에 유용 할 수 있습니다.)

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 골프가 아닌 언어로 답변을 게시하지 못하게하십시오. 모든 프로그래밍 언어에 대해 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 답변에 적용 되므로 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

온라인으로 사용해보십시오!

수정 된 테스트 스위트

파이썬 3, 40 바이트

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

테스트는 아이디어입니다

map(str, a)발전기를 만들고, G그 통화 str의 각 값에이 a문자열로 변환하는
map(int, G, [10]+a)발전기를 만듭니다 통화 int(g, v)에서 쌍 G및 [10]+a
int(g, v)문자열 변환 g정수베이스에서 v(경우 v에 [2,36]및 g유효)
sum가 주석에서 말하는 수행

파이썬 2, 48 바이트

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

테스트는 아이디어입니다

zip(a,[10]+a)의 값의 쌍을 통과 a하고, 이전 값 또는 10첫 번째에 대한 의 호출로 변환 문자열로, 문자열로 변환 정수베이스에서을 (경우 에 및 유효) 가 주석에서 말하는 수행
backticksintxs
int(s, y)syy[2,36]s
sum

펄, 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및while 수행) 하므로 이전 루프의 일치 결과를 현재 루프에서 계속 사용할 수 있습니다. 나는 기본이로 사용할 수있는 작업을 수행하는 순서에주의 해요 그렇다면 "$`$&", 내가 사용 그래서 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

온라인으로 사용해보십시오!

자바, 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})));
  }
}

자바 스크립트 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 $@;).

이데온

자바 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 덕분에 20 바이트가 나왔습니다 (어리석은 실수 때문에 12 개가되었습니다 ).

언 골프 및 테스트 코드 :

여기에서 시도하십시오.

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.

하스켈, 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

자바 스크립트 (ES6), 54 48 40 바이트

나는 재귀 접근법을 사용했다.

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

Lmis 덕분에 6 바이트를 절약했습니다!
Neil 덕분에 8 바이트를 더 절약했습니다!

펄 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 $_
      }>"
    }
}

파이썬 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[]

이전 요소를 기본 및 합계로 사용하여 각 숫자를 구문 분석합니다 (첫 번째 제외). 끝에 첫 번째 요소를 추가합니다

루비, 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

스칼라, 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

수학, 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은 숫자를 나타내는 0이 추가 된 입력 인수 목록입니다. {10,##}10이 앞에 붙은 입력 인수의 목록입니다 (기본을 나타냄). 이 쌍의리스트는 Transposed와 각각의 숫자를 밑수와 연관시키기 위해 d이며, FromDigits(yay!)는 각 숫자-베이스 쌍을 밑이 10 인 정수로 변환합니다 Tr.

커먼 리스프, 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구조체는 수락 "W 다음 V"를 반복 구조, 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