Ziel dieser Herausforderung ist es, ein Programm zu schreiben, mit dem eine eingegebene Zeichenfolge, von der angenommen werden kann, dass sie nur Buchstaben und Zahlen aus möglichst vielen Basen zwischen 2 und 36 enthält, konvertiert und die Summe der Ergebnisse zur Basis 10 ermittelt wird.

Die Eingabezeichenfolge wird an alle Basen überführt werden , in dem die Nummer für bis zu 36 Basen nach dem Standard Alphabet definiert wäre: 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ. Beispielsweise 2Twäre die Eingabe nur in den Basen 30 und höher gültig. Das Programm würde 2T von den Basen 30 bis 36 in Dezimalzahlen konvertieren und die Ergebnisse summieren.

Sie können davon ausgehen, dass die Eingabezeichenfolge nur Buchstaben und Zahlen enthält. Ihr Programm verwendet möglicherweise Groß- oder Kleinbuchstaben. es kann, muss aber nicht beides unterstützen.

Testfälle

Beispieleingabe: 2T

Tabelle möglicher Basen

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

Ausgabe: 665

Beispieleingabe: 1012

Tabelle möglicher Basen:

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

Ausgabe: 444278

Beispieleingabe: HELLOworld

Tabelle möglicher Basen

Base   Value
33     809608041709942
34     1058326557132355
35     1372783151310948
36     1767707668033969

Ausgabe: 5008425418187214

Eine Eingabe von 0würde wie 0in allen Basen zwischen 2 und einschließlich 36 gelesen werden . Es gibt keine Basis 1.

Das ist Code Golf. Es gelten Standardregeln. Kürzester Code in Bytes gewinnt.

Python 3, 72 71 69 Bytes

Vielen Dank an FryAmTheEggman für das Speichern eines Bytes!

Danke an DSM für das Speichern von 2 Bytes!

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

Pyth, 20 - 19 - 11 Bytes

sm.xizd0S36

Offensichtlich stahl Adnans Idee aus seiner Python-Antwort.

Probieren Sie es hier aus

Pure Bash (keine Dienstprogramme), 38

Vorausgesetzt, integrierte Basisumwandlungen sind zulässig:

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

Dies gibt einen Fehler an STDERR aus. Ich gehe davon aus, dass dies gemäß dieser Meta-Antwort in Ordnung ist .

Testausgang:

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

Mathematica, 57 Bytes

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

Im Ernst, 65 Bytes

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

Enthält nicht druckbare Hexdumps:

2c963bbb726b6022303132333435363738394142434445464748494a4b4c4d4e4f505152535455565758595a22a175604d53643a33373a407860bda8604de42e7f

Leider habe ich keine gute Möglichkeit, anhand von Typen aus einer Liste zu filtern. Notiz an mich selbst: füge das hinzu.

Nimmt Eingaben wie "2T"

Probieren Sie es online aus (Sie müssen die Eingabe manuell eingeben)

Erläuterung:

,û    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 Bytes

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

Octave, 75 73 Bytes

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

Erläuterung:

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

polyvalhat den Vorteil, base2decdass es vektorisiert ist, so dass keine forSchleife erforderlich ist.

Als Eingabe werden nur '0' .. '9' und Großbuchstaben 'A' .. 'Z' unterstützt.

Japt , 26 Bytes

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

Probieren Sie es online!

Ungolfed und Erklärung

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 Bytes

V36 .x=+ZizhN ;Z

Probieren Sie es online aus

Erklärung:

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

Vielen Dank an Reto Koradi für das Speichern von 1 Byte.

Das ist irgendwie schrecklich ...

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

Erfordert Großbuchstaben.

Teste es hier.

CJam verfügt nicht über eine integrierte Base-36-Konvertierung von Strings, daher müssen wir die Strings selbst ausbuchstabieren. Ich habe alle möglichen Divmod-Spielereien ausprobiert, aber es scheint am kürzesten zu sein, eine Zeichenfolge mit allen 36 Ziffern zu erstellen und einfach den Index jedes Zeichens in dieser Zeichenfolge zu finden.

C-Funktion, 93 (nur 32-Bit-Integer-Ausgabe)

Angenommen, es ist OK, damit die Ausgabe nur bis zu INT_MAX geht, dann können wir dies tun:

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

Der letzte Testfall impliziert, dass dies wahrscheinlich nicht ausreicht. Wenn ja, dann haben wir mit 64-Bit-Ganzzahlen:

C-Funktion, 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);}

Leider #include <stdlib.h>ist das erforderlich, damit der Rückgabetyp strtoll()korrekt ist. Wir müssen verwenden long long, um den HELLOworldTestfall zu behandeln . Ansonsten könnte dies etwas kürzer sein.

Testfahrer:

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

Testausgang:

$ ./basesum
0
665
444278
5008425418187214
$ 

Python 3, 142 Bytes

Adnan hat mich mit ihrer Lösung klar geschlagen, aber ich wollte meinen eigenen Versuch hinzufügen.

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

Diese Funktion verarbeitet nur Eingaben in Großbuchstaben. Add .upper()to for i in s, und es wird sowohl Groß- als auch Kleinbuchstaben verarbeiten.

Scala 2.11, 93 Bytes

Dies wird auf der Scala-Konsole ausgeführt.

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

Haskell, 97 Bytes

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

Unterstützt nur Kleinbuchstaben. Anwendungsbeispiel:

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

Es ist so gewaltig, weil ich sowohl Char-to-ASCII- als auch Base-Konvertierung selbst implementieren muss. Die entsprechenden vordefinierten Funktionen befinden sich in Modulen, die noch teurere Importe erfordern.

So funktioniert es: iWandelt ein Zeichen cin seinen Ziffernwert um (zB i 't'-> 29). fberechnet den Wert der Eingabezeichenfolge für jede mögliche Basis und summiert ihn. Eine nicht-punktfreie Version der inneren Schleife ist map (\base -> foldl1 (\value digit -> value*base + digit) (map i s)) [ ...bases... ].

JavaScript (ES6), 86 Byte

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

Erläuterung

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

Prüfung

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

Perl 6 , 35 Bytes

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

Verwendung:

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

say code 'HELLOworld' # 5008425418187214

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

say code 'qwertyuiopasdfghjklzxcvbnm1234567890'
# 79495849566202185148466281109757186006261081372450955140

Ceylon, 100 96 Bytes

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

Ich hatte zuerst diese einfachere Version mit nur 69 Bytes:

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

Dies schlägt jedoch mit dem ersten Testfall fehl und wird 2000000000665stattdessen zurückgegeben665 . ( Der Grund ist, dass das Tin 2Tals Tera analysiert wird, dh die 2 mit 10 ^ 12 multipliziert wird, wenn der Radix 10 ist. ) Daher müssen wir diesen Fall separat erfassen. _{Vielen Dank an Neil , der eine andere Methode vorgeschlagen hat, mit der 4 Byte eingespart wurden.}

Formatiert:

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