이 과제의 목표는 가능한 한 2에서 36 사이의 많은 수의 문자와 숫자 만 포함하는 것으로 가정 할 수있는 입력 된 문자열을 변환 하고 결과의 기본 10 합계를 찾는 프로그램을 작성하는 것입니다.

입력 문자열은 최대 36 개의베이스에 대한 표준 알파벳에 따라 숫자가 정의되는 모든베이스로 변환됩니다 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ. 예를 들어, 입력 2T은베이스 30 이상에서만 유효합니다. 이 프로그램은 2T를 기수 30에서 36으로 10 진수로 변환하고 결과를 합산합니다.

입력 문자열에 문자와 숫자 만 포함되어 있다고 가정 할 수 있습니다. 프로그램은 대문자 또는 소문자를 사용할 수 있습니다. 두 가지를 모두 지원할 수는 있지만 반드시 필요한 것은 아닙니다.

테스트 사례

샘플 입력 : 2T

가능한 염기의 차트

Base   Value
30     89
31     91
32     93
33     95
34     97
35     99
36     101

출력 : 665

샘플 입력 : 1012

가능한 염기도 :

Base   Value
3      32
4      70
5      132
6      224
7      352
8      522
9      740
10     1012
11     1344
12     1742
13     2212
14     2760
15     3392
16     4114
17     4932
18     5852
19     6880
20     8022
21     9284
22     10672
23     12192
24     13850
25     15652
26     17604
27     19712
28     21982
29     24420
30     27032
31     29824
32     32802
33     35972
34     39340
35     42912
36     46694

산출: 444278

샘플 입력 : HELLOworld

가능한 염기의 차트

Base   Value
33     809608041709942
34     1058326557132355
35     1372783151310948
36     1767707668033969

산출: 5008425418187214

입력은 2에서 36 사이의 모든 기수에서와 0같이 읽습니다 0. 기본 1과 같은 것은 없습니다.

이것은 코드 골프입니다. 표준 규칙이 적용됩니다. 바이트 단위의 최단 코드가 이깁니다.

파이썬 3, 72 71 69 바이트

바이트를 저장해 준 FryAmTheEggman에게 감사합니다!

2 바이트를 절약 한 DSM에 감사합니다!

N=x=0
y=input()
while N<36:
 N+=1
 try:x+=int(y,N)
 except:0
print(x)

Pyth, 20 19 11 바이트

sm.xizd0S36

그의 대답에서 뻔뻔스럽게 Adnan의 아이디어를 훔쳤다.

여기 사용해보십시오

순수 배쉬 (유틸리티 없음), 38

기본 제공 기본 변환이 허용된다고 가정합니다.

for((b=36;s+=$b#$1;b--));{ :;}
echo $s

STDERR에 오류가 출력됩니다. 이 메타 답변에 따라 이것이 정상이라고 가정합니다 .

테스트 출력 :

$ for t in 0 2T 1012 HELLOworld; do ./basesum.sh $t; done 2> /dev/null
0
665
444278
5008425418187214
$ 

매스 매 티카, 57 바이트

#~Sum~{x,Max@CoefficientList[#,x]+1,36}&@FromDigits[#,x]&

정말 65 바이트

,û;╗rk`"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"íu`MSd:37:@x`╜¿`MΣ.

인쇄 할 수없는 hexdump를 포함합니다.

2c963bbb726b6022303132333435363738394142434445464748494a4b4c4d4e4f505152535455565758595a22a175604d53643a33373a407860bda8604de42e7f

불행히도 유형을 기반으로 목록에서 필터링하는 좋은 방법이 없습니다. 자기 자신에 대한 참고 사항 : 추가하십시오.

다음과 같은 입력을받습니다. "2T"

온라인으로 사용해보십시오 (입력을 수동으로 입력해야 함)

설명:

,û    get input and convert to uppercase
;╗    make a copy and save to register 0
rk    explode string into list
`"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"íu`M  map the function over the list:
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"íu    get the character's index in the string and add one to get a value in [1,36]
Sd    get maximum element (maximum base aka max_base) from list by sorting and popping the last element off and pushing it to the stack
:37:@x  push range(max_base,37)
`╜¿`M  map the function over the list:
    ╜¿    convert value in register 0 to an int, interpreting it as a base-n int (n is value from list)
Σ.    sum and print
0x7f  quit

Matlab, 98 바이트

function y=f(s)
[~,m]=max(bsxfun(@eq,s,[48:57 65:90]'));y=0;for n=max(m):36
y=y+base2dec(s,n);
end

옥타브, 75 73 바이트

function v=u(a) m([48:57 65:90])=0:35;v=sum(polyval(t=m(a),max(t)+1:36));

설명:

function v=u(a) 
   m([48:57 65:90])=0:35; %// create a map: '0'-'9' = 0-9
                          %//               'A'-'Z' = 10-35
   t=m(a);                %// convert string to mapped values
   b=max(t)+1;            %// find minimum base
   p=polyval(t,b:36);     %// calculate polynomial for each base (vectorized)
   v=sum(p);              %// and return the sum of the resulting vector

polyvalbase2dec벡터화되어 있다는 장점이 있으므로 for루프가 필요 하지 않습니다.

'0'.. '9'및 대문자 'A'.. 'Z'만 입력으로 지원됩니다.

apt , 26 바이트

1+U¬r@XwYn36}0)o37 £UnX} x

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

언 골프와 설명

1+U¬ r@   XwYn36}0)o37 £    UnX} x
1+Uq rXYZ{XwYn36}0)o37 mXYZ{UnX} x

           // Implicit: U = input string
Uq rXYZ{   // Split U into chars, and reduce each item Y and previous value X by:
XwYn36     //  Choosing the larger of X and parseInt(Y,36),
}0         // starting at 0.
1+   )o37  // Add 1 and create a range from this number to 36.
mXYZ{UnX}  // Map each item X in this range to parseInt(U,X)
x          // and sum.
           // Implicit: output last expression

Pyth, 16 바이트

V36 .x=+ZizhN ;Z

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

설명 :

                 # Implicit: Z = 0, z = input
V36              # For N in range 36
    .x           # Try except
      =+Z        # Z = Z + izhN
         izhN    # Convert z from base N+1 to decimal
              ;  # Infinite ), for closing the for loop
               Z # Print Z

CJam, 28 27 바이트

1 바이트를 절약 한 Reto Koradi에게 감사합니다.

이건 좀 끔찍 해요 ...

qA,s'[,65>+f#_:e>)37,>\fb:+

대문자가 필요합니다.

여기에서 테스트하십시오.

CJam은 문자열에서 기본 36 변환을 제공하지 않으므로 문자열 자체를 직접 작성해야합니다. 나는 모든 종류의 divmod shenanigan을 시도했지만 36 자릿수의 문자열을 작성하고 해당 문자열에서 각 문자의 색인을 찾는 것이 가장 짧은 것 같습니다.

C 함수, 93 (32 비트 정수 출력 만 해당)

출력이 INT_MAX까지만 올라간다고 가정하면 다음과 같이 할 수 있습니다.

i,n,x;f(char *s){char *e;for(i=36,x=0;n=strtol(s,&e,i--),!*e&&i;)x+=*e?0:n;printf("%d\n",x);}

마지막 테스트 케이스는 이것이 충분하지 않다는 것을 암시합니다. 그렇다면 64 비트 정수로 다음을 얻습니다.

C 함수, 122

#include<stdlib.h>
f(char *s){long long i=36,n,x=0;char *e;for(;n=strtoll(s,&e,i--),!*e&&i;)x+=*e?0:n;printf("%lld\n",x);}

불행히도의 #include <stdlib.h>반환 유형 strtoll()이 정확해야합니다. 테스트 케이스 long long를 처리하는 데 사용해야 합니다 HELLOworld. 그렇지 않으면 이것은 조금 더 짧을 수 있습니다.

테스트 드라이버 :

#include<stdlib.h>
f(char *s){long long i=36,n,x=0;char *e;for(;n=strtoll(s,&e,i--),!*e&&i;)x+=*e?0:n;printf("%lld\n",x);}

int main (int argc, char **argv)
{
    f("0");
    f("2T");
    f("1012");
    f("HELLOworld");
}

테스트 출력 :

$ ./basesum
0
665
444278
5008425418187214
$ 

파이썬 3, 142 바이트

Adnan 은 그들의 솔루션을 능숙하게 극복했지만 내 시도를 추가하고 싶었습니다.

def f(s):
 t=0
 for x in range(37):
  n=0
  for i in s:
   try:m=int(i)
   except:m=ord(i)-55
   if x<=m:n=0;break
   n=n*x+m
  t+=n
 return t

이 기능은 대문자 입력 만 처리합니다. 에 추가 .upper()하면 for i in s대문자와 소문자를 모두 처리합니다.

스칼라 2.11, 93 바이트

이것은 scala 콘솔에서 실행됩니다.

val i=readLine
var s=0
for(j<-2 to 36)try{s=s+Integer.parseInt(i,j)}catch{case _:Exception=>}

하스켈, 97 바이트

i c|'_'<c=fromEnum c-87|1<2=read[c]
f s=sum$map((`foldl1`map i s).((+).).(*))[1+i(maximum s)..36]

소문자 만 지원합니다. 사용 예 :

f "2t"           -> 665
f "helloworld"   -> 5008425418187214

char-to-ASCII와 기본 변환을 모두 구현해야하기 때문에 너무 방대합니다. 사전 정의 된 해당 기능은 더 비싼 가져 오기가 필요한 모듈에 있습니다.

작동 방식 : i문자 c를 숫자 값으로 변환 합니다 (예 : i 't'-> 29). f가능한 모든 기준에 대한 입력 문자열 값을 계산하고 합계합니다. 내부 루프의 비 포인트 프리 버전은입니다 map (\base -> foldl1 (\value digit -> value*base + digit) (map i s)) [ ...bases... ].

자바 스크립트 (ES6), 86 바이트

s=>eval(`p=parseInt;b=2;[...s].map(d=>(v=p(d,36))>b?b=v:0);for(r=0;++b<37;)r+=p(s,b)`)

설명

s=>
  eval(`                     // use eval to enable for loop without return keyword or {}
    p=parseInt;
    b=2;                     // b = minimum base of s
    [...s].map(d=>           // iterate through each digit d
      (v=p(d,36))            // get it's base-36 value
        >b?b=v:0             // set b to the max value
    );
    for(r=0;++b<37;)         // r = sum of all base values
      r+=p(s,b)              // add each base value from b to 36 to r
  `)                         // implicit: return r

테스트

<input type="text" id="input" value="HELLOworld" />
<button onclick="result.textContent=(

s=>eval(`p=parseInt;b=2;[...s].map(d=>(v=p(d,36))>b?b=v:0);for(r=0;++b<37;)r+=p(s,b)`)

)(input.value)">Go</button>
<pre id="result"></pre>

펄 6 , 35 바이트

{[+] map {+(":$^a"~"<$_>")||0},^37}

용법:

# store it somewhere
my &code = {[+] map {+(":$^a"~"<$_>")||0},^37}

say code 'HELLOworld' # 5008425418187214

say map &code, <2T 1012>
# (665 444278)

say code 'qwertyuiopasdfghjklzxcvbnm1234567890'
# 79495849566202185148466281109757186006261081372450955140

실론, 100 96 바이트

Integer b(String s)=>sum(((any(s*.letter)then 11else 2)..36).map((r)=>parseInteger(s,r)else 0));

나는이 간단한 버전을 처음 69 바이트 만 사용했습니다.

Integer b(String s)=>sum((2..36).map((r)=>parseInteger(s,r)else 0));

그러나 이것은 첫 번째 테스트 사례에서 실패하고 2000000000665대신에 반환 됩니다 665. ( 의 이유는 Tin 2T이 Tera로 구문 분석되기 때문입니다 . 즉 기수가 10 일 때 2에 10 ^ 12를 곱하기 때문입니다. ) 따라서 우리는이 경우 별도로 잡을 필요가있다. _{4 바이트를 절약 할 수있는 다른 방법을 제안 해 준 Neil 에게 감사드립니다 .}

형식화 :

// Find sum of all possible base representations.
//
// Question:  /codegolf//q/65748/2338
// My Answer: /codegolf//a/65836/2338

Integer b(String s) =>
// take the sum of ...
        sum(
    // span from 2 to 36. (Though
    // if there are letters in there, we start at 11,
    // because the other ones can't be valid.
    // Also, parseInteger(s, 10) behaves a bit strange in Ceylon.)
    ((any(s*.letter) then 11 else 2) .. 36)
    // map each r of them to ...
        .map((r) =>
            // try parsing s as a number using base r
            parseInteger(s, r)
            // if that didn't succeed, use 0.
                    else 0
    )
);