Hier ist eine schöne einfache Herausforderung:

Bestimmen Sie anhand einer Zeichenfolge, die eine Zahl in einer unbekannten Basis darstellt, die niedrigste mögliche Basis, in der sich diese Zahl möglicherweise befindet. Die Zeichenfolge enthält nur 0-9, a-z. Wenn Sie möchten, können Sie Großbuchstaben anstelle von Kleinbuchstaben verwenden. Geben Sie dies jedoch an. Sie müssen diese niedrigstmögliche Basis dezimal ausgeben.

Hier ist ein konkreteres Beispiel. Wenn die Eingabezeichenfolge "01234" war, ist es unmöglich, dass diese Zahl binär ist, da 2, 3 und 4 in binär nicht definiert sind. In ähnlicher Weise kann diese Zahl nicht 4. Daher in der Basis 3 oder Base sein, diese Zahl muss in der Basis-5 sein, oder eine höhere Basis, so sollten Sie Ausgang ‚5‘.

Ihr Code muss für jede Basis zwischen Basis 1 (unär, alle Nullen) und Basis 36 ('0-9' und 'a-z') funktionieren.

Sie können Eingaben vornehmen und Ausgaben in jedem vernünftigen Format bereitstellen. Buildins für die Basiskonvertierung sind zulässig. Wie üblich gelten Standardlücken und die kürzeste Antwort in Bytes ist der Gewinner!

Test IO:

#Input          #Output
00000       --> 1
123456      --> 7
ff          --> 16
4815162342  --> 9
42          --> 5
codegolf    --> 25
0123456789abcdefghijklmnopqrstuvwxyz    --> 36

Gelee , 4 Bytes

ṀØBi

Benötigt Großbuchstaben. Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

ṀØBi  Main link. Arguments: s (string)

Ṁ     Yield the maximum of s.
 ØB   Yield "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".
   i  Find the 1-based index of the maximum in that string.

Python, 27 22 Bytes

lambda s:(max(s)-8)%39

Dies erfordert, dass die Eingabe ein Bytestring (Python 3) oder ein Bytearray (Python 2 und 3) ist.

Vielen Dank an @AleksiTorhamo für das Abschlagen von 5 Bytes!

Teste es auf Ideone .

Wie es funktioniert

Wir beginnen mit dem Maximum der Zeichenkette. Hierbei sind die Codepunkte der Buchstaben höher als die Codepunkte der Ziffern, wobei dieses maximale Zeichen auch die maximale Basisziffer 36 ist.

Der Codepunkt von '0' - '9' ist 48 - 57 , daher müssen wir 48 von ihren Codepunkten abziehen , um die entsprechenden Ziffern zu berechnen , oder 47 , um die niedrigstmögliche Basis zu berechnen. Ähnlich werden die Codepunkte des Buchstaben ‚A‘ - ‚Z‘ sind 97 bis 122 . Da 'a' die Ziffer mit dem Wert 10 darstellt , müssen wir 87 von ihren Codepunkten abziehen , um die entsprechenden Ziffern zu berechnen , oder 86 , um die niedrigstmögliche Basis zu berechnen. Ein Weg, dies zu erreichen, ist wie folgt.

Der Unterschied zwischen 97 und 58 ( ':' , das Zeichen nach '9' ) beträgt 39 , sodass die Subtraktion mit den Codepunkten modulo 39 erzielt werden kann. Da 48% 39 = 9 , und das gewünschte Ergebnis für das Zeichen ‚0‘ ist 1 , subtrahieren wir zuerst 8 , bevor das Ergebnis modulo Aufnahme 39 . Zuerst muss subtrahiert werden, da sonst 'u'% 39 = 117% 39 = 0 ist .

c    n    n-8    (n-8)%39
0    48    40     1
1    49    41     2
2    50    42     3
3    51    43     4
4    52    44     5
5    53    45     6
6    54    46     7
7    55    47     8
8    56    48     9
9    57    49    10
a    97    89    11
b    98    90    12
c    99    91    13
d   100    92    14
e   101    93    15
f   102    94    16
g   103    95    17
h   104    96    18
i   105    97    19
j   106    98    20
k   107    99    21
l   108   100    22
m   109   101    23
n   110   102    24
o   111   103    25
p   112   104    26
q   113   105    27
r   114   106    28
s   115   107    29
t   116   108    30
u   117   109    31
v   118   110    32
w   119   111    33
x   120   112    34
y   121   113    35
z   122   114    36

Python, 25 Bytes

lambda x:int(max(x),36)+1

Definiert ein Lambda, das die Zeichenfolge annimmt x. Findet die größte Ziffer in der Zeichenfolge (standardmäßig nach Buchstaben über den Ziffern sortiert) und konvertiert sie zur Basis 36. Fügt 1 hinzu, da sie 8nicht zur Basis 8 gehört.

Haskell, 34 Bytes

f s=length['\t'..maximum s]`mod`39

Verwendet die mod(ord(c)-8,39)Idee von Dennis.

41 Bytes

g '0'=1
g 'W'=1
g x=1+g(pred x)
g.maximum

45 Bytes:

(`elemIndex`(['/'..'9']++['a'..'z'])).maximum

Ausgänge mögen Just 3.

Cheddar , 34 29 21 Bytes

8 Bytes dank Dennis gespart !!!

s->(s.bytes.max-8)%39

Verwendet Kleinbuchstaben

Probieren Sie es online aus

Erläuterung

s -> (      // Input is `s`
  s.bytes    // Returns array of char codes
   .max      // Get maximum item in array
) % 39      // Modulus 39

05AB1E , 6 Bytes

{¤36ö>

Nimmt Buchstaben in Großbuchstaben.

Erläuterung

{       # sort
 ¤      # take last
  36ö   # convert from base 36 to base 10
     >  # increment

Probieren Sie es online aus

Eigentlich 6 Bytes

M6²@¿u

Probieren Sie es online!

Julia, 22 Bytes

!s=(maximum(s)-'')%39

Zwischen den Anführungszeichen steht ein BS-Zeichen (0x08). Probieren Sie es online!

JavaScript (ES6), 41 37 Byte

s=>parseInt([...s].sort().pop(),36)+1

Bearbeiten: 4 Bytes dank @ edc65 gespeichert.

Haskell, 55 40 Bytes

f=(\y->mod(y-8)39).Data.Char.ord.maximum

Danke @Dennis für seinen Ansatz. (nimm das, @xnor;))

Perl 6: 18 Bytes

{:36(.comb.max)+1}

Definiert ein Lambda, das ein einzelnes Zeichenfolgenargument akzeptiert und eine Ganzzahl zurückgibt. Es teilt den String in Zeichen auf, findet den "höchsten", konvertiert ihn in Basis 36 und addiert 1.

{(.ords.max-8)%39}

Dieser nutzt den Modulo-Ansatz von Dennis. Die gleiche Länge.

Retina , 28 Bytes

O`.
.\B

{2`
$`
}T01`dl`_o
.

Probieren Sie es online! (Die erste Zeile aktiviert eine durch Zeilenvorschub getrennte Testsuite.)

Erläuterung

O`.

Dies sortiert die Zeichen der Eingabe.

.\B

Dadurch werden alle Zeichen mit Ausnahme des letzten entfernt, sodass in den ersten beiden Schritten das maximale Zeichen ermittelt wird.

{2`
$`
}T01`dl`_o

Dies sind zwei Stufen, die eine Schleife bilden. Das erste dupliziert das erste Zeichen und das zweite "dekrementiert" es (ersetzt zB xmit w, amit 9und 1mit 0). Die letzte Stufe trifft auf eine Null als erstes Zeichen, sie entfernt sie stattdessen. Dies ist eine Standardtechnik zum Erzeugen einer Reihe von Zeichen am oberen Ende. Somit werden alle "Ziffern" von 0bis zur maximalen Ziffer erzeugt.

.

Schließlich zählen wir einfach die Anzahl der Stellen, die uns die Basis gibt.

R 99 89 85 Bytes

Aussehen ! Weniger als 100 Bytes!
Aussehen ! 10 Bytes aus!
Aussehen ! 4 Bytes aus!

ifelse((m=max(strsplit(scan(,''),"")[[1]]))%in%(l=letters),match(m,l)+10,strtoi(m)+1)

Ungolfed:

l=letters                  #R's built-in vector of lowercase letters

n=scan(what=characters())  #Takes an input from STDIN and convert it to characters

m=max(strsplit(n,"")[[1]]) #Splits the input and takes to max. 
                           #`letters` are considered > to numbers (i.e. a>1)


ifelse(m%in%l,match(m,l)+10,strtoi(m)+1) #If the max is in `letters`,
                                             #outputs the matching position of `m`in `letters` + 10 (because of [0-9]). 
                                             #Else, outputs `m` (as a number) + 1.

Wie so oft benutzt diese Antwort die ifelseFunktion:ifelse(Condition, WhatToDoIfTrue, WhatToDoElse)

PHP, 51 38 Bytes

(Von Dennis) ^^

<?=(ord(max(str_split($argv[1])))-8)%39;

Anderer Vorschlag ohne Dennis 'Trick

<?=($a=max(str_split($argv[1])))<a?$a+1:ord($a)-86;

• Übernimmt die Eingabe als Argument $ argv [1];
• Max. Zeichen (unter Verwendung von ASCII)
• Wenn es sich um eine Zahl handelt (die unter dem Wert <'a' liegt), geben Sie die Zahl + 1 aus
• Andernfalls wird der ASCII-Wert -86 ausgegeben (97 für 'a' in ASCII, -11 für 'a' ist die elfte Basisziffer).

Oktave, 20 Bytes

@(a)mod(max(a)-8,39)

Pyke, 6 Bytes

Seb36h

Probieren Sie es hier aus!

Se     -   sorted(input)[-1]
  b36  -  base(^, 36)
     h - ^ + 1

Java 7, 67 61 Bytes

int c(char[]i){int m=0;for(int c:i)m=m>c?m:c;return(m-8)%39;}

(m-8)%39ist dank @Dennis 'erstaunlicher Antwort .

Ungolfed & Testcode:

Probieren Sie es hier aus.

class Main{
  static int c(char[] i){
    int m = 0;
    for(int c : i){
      m = m > c
           ? m
           : c;
    }
    return (m-8) % 39;
  }

  public static void main(String[] a){
    System.out.println(c("00000".toCharArray()));
    System.out.println(c("123456".toCharArray()));
    System.out.println(c("ff".toCharArray()));
    System.out.println(c("4815162342".toCharArray()));
    System.out.println(c("42".toCharArray()));
    System.out.println(c("codegolf".toCharArray()));
    System.out.println(c("0123456789abcdefghijklmnopqrstuvwxyz".toCharArray()));
  }
}

Ausgabe:

1
7
16
9
5
25
36

C89, 55 53 52 50 Bytes

f(s,b)char*s;{return*s?f(s+1,*s>b?*s:b):(b-8)%39;}

-8%39 schamlos von Dennis gestohlen

Prüfung

test(const char* input)
{
    printf("%36s -> %u\n", input, f((char*)input,0));
}

main()
{
    test("00000");
    test("123456");
    test("ff");
    test("4815162342");
    test("42");
    test("codegolf");
    test("0123456789abcdefghijklmnopqrstuvwxyz");
}

Ausgabe

                               00000 -> 1
                              123456 -> 7
                                  ff -> 16
                          4815162342 -> 9
                                  42 -> 5
                            codegolf -> 25
0123456789abcdefghijklmnopqrstuvwxyz -> 36

Dank Toby Speight 2 Bytes gespart

2 Bytes dank Kevin Cruijssen gespeichert

C 55 Bytes

Diese Antwort setzt voraus, dass die Eingabe in ASCII erfolgt (oder in den Zahlen und Buchstaben identisch ist, z. B. ISO-8859 oder UTF-8):

m;f(char*s){for(m=0;*s;++s)m=m>*s?m:*s;return(m-8)%39;}

Wir iterieren einfach entlang des Strings, wobei wir uns den größten Wert merken, und verwenden dann die bekannte Modulo-39-Konvertierung von base- {11..36}.

Testprogramm

int printf(char*,...);
int main(int c,char **v){while(*++v)printf("%s -> ",*v),printf("%d\n",f(*v));}

Testergebnisse

00000 -> 1
123456 -> 7
ff -> 16
4815162342 -> 9
42 -> 5
codegolf -> 25
0123456789abcdefghijklmnopqrstuvwxyz -> 36

Mathematica, 34 32 Bytes

2 Bytes gespart dank Martin Ender

Max@Mod[ToCharacterCode@#-8,39]&

Ich entschied, dass die andere Methode eine neue Antwort verdient.

_{Methode gestohlen, inspiriert von Dennis 'Lösung}

Mathematica, 34 32 Bytes

2 Bytes gespart dank Martin Ender

Max@BaseForm[Characters@#,36]+1&

Definiert eine reine Funktion, die eine Zeichenfolge als Eingabe akzeptiert.

Teilt die Eingabe in Zeichen auf, konvertiert sie in Zahlen zur Basis 36 und gibt das Maximum +1 zurück.

C # REPL, 17 Bytes

x=>(x.Max()-8)%39

Nur portiert @ Dennis Antwort auf C #.

CJam, 10 Bytes

Vielen Dank an Martin Ender, der mir ein paar Bytes gespart hat!

Verwendet Dennis Formel

q:e>8-i39%

Probieren Sie es online aus

CJam, 18 16 Btyes

Alternative Lösung:

A,s'{,97>+q:e>#)

Probieren Sie es online aus

A,s'{,97>+       e# Push the string "0123456789abcdefghijklmnopqrstuvwxyz"
          q      e# Get the input
           :e>   e# Find the highest character in the input
              #  e# Find the index of that character in the string
               ) e# Increment

Scala, 25 Bytes

print((args(0).max-8)%39)

Führen Sie es wie folgt aus:

$ scala whatbase.scala 0123456789abcdefghijklmnopqrstuvwxyz

R 62 54 Bytes

max(match(strsplit(scan(,''),"")[[1]],c(0:9,letters)))

Ungolfed:

max(
  match( # 2: Finds the respective positions of these characters
    strsplit(scan(,''),"")[[1]], # 1: Breaks the input into characters
                                c(0:9,letters)) # 3: In the vector "0123...yz"
                                                )

Update: 8 Bytes wurden aufgrund der Redundanz von na.rm=Tunter der Annahme der Eingabegültigkeit abgeschnitten .

Eine Größenverbesserung von 39% im Vergleich zu Frédérics Antwort . Außerdem läuft es ein bisschen schneller: 0,86 Sekunden für 100000 Replikationen gegenüber 1,09 Sekunden für die konkurrierende Antwort. Meiner ist also kleiner und effizienter.

Dyalog APL , 10 Bytes

Fordert zur Eingabe von Großbuchstaben auf.

⌈/⍞⍳⍨⎕D,⎕A

⌈/ maximal

⍞ Zeichen der Eingabe

⍳⍨ 1-indiziert in

⎕D, Alle Ziffern gefolgt von

⎕A alle Zeichen

TryAPL online!

BASH 70

grep -o .|sort -r|head -c1|od -An -tuC|sed s/$/-86/|bc|sed s/-/39-/|bc

Eingabebuchstaben sind Kleinbuchstaben.

JavaScript, 57 50 48 Bytes

7 Bytes gespart dank @ kamaroso97 2 Bytes gespart dank @Neil

n=>Math.max(...[...n].map(a=>parseInt(a,36))+1)

Ursprüngliche Antwort:

n=>n.split``.map(a=>parseInt(a,36)).sort((a,b)=>b-a)[0]+1

Perl, 30 27 Bytes

Beinhaltet +1 für -p

Führen Sie mit der Eingabe auf STDIN, z

base.pl <<< codegolf

base.pl:

#!/usr/bin/perl -p
\@F[unpack"W*"];$_=@F%39-9

LiveScript, 32 Bytes

->1+parseInt (it/'')sort!pop!,36

Ein Port dieser Antwort in meiner Lieblingssprache, die mit JavaScript kompiliert wird. Wenn der base~numberOperator mit Variablen arbeiten würde, könnte ich schreiben ->1+36~(it/'')sort!pop!(23 Bytes), aber das widerspricht dem Funktionsbindungsoperator: /