Oto całkiem proste wyzwanie:

Biorąc pod uwagę ciąg reprezentujący liczbę w nieznanej bazie, określ najniższą możliwą bazę, w której może znajdować się liczba. Ciąg będzie zawierał tylko 0-9, a-z. Jeśli chcesz, możesz wybrać wielkie litery zamiast małych, ale określ to. Musisz podać tę najniższą możliwą podstawę w systemie dziesiętnym.

Oto bardziej konkretny przykład. Jeśli ciąg wejściowy to „01234”, to niemożliwe jest, aby ta liczba była binarna, ponieważ 2, 3 i 4 są niezdefiniowane binarnie. Podobnie, liczba ta nie może znajdować się w podstawie 3 ani w bazie 4. Dlatego też liczba ta musi znajdować się w podstawie 5 lub wyższej, więc powinieneś wypisać „5”.

Twój kod musi działać dla dowolnej bazy między bazą 1 (unary, wszystkie „0”) a bazą 36 („0-9” i „a-z”).

Możesz przyjmować dane wejściowe i dostarczać dane wyjściowe w dowolnym rozsądnym formacie. Wbudowane konwersje podstawowe są dozwolone. Jak zwykle obowiązują standardowe luki, a zwycięzcą jest najkrótsza odpowiedź w bajtach!

Test IO:

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

Galaretka , 4 bajty

ṀØBi

Wymaga wielkich liter. Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe .

Jak to działa

ṀØ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 bajtów

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

Wymaga to, aby dane wejściowe były bajtowaniem (Python 3) lub bajtowaniem (Python 2 i 3).

Dzięki @AleksiTorhamo za grę w golfa z 5 bajtów!

Przetestuj na Ideone .

Jak to działa

Zaczynamy od pobrania maksimum ciągu. To, że punkty kodowe liter są wyższe niż punkty kodowe cyfr, ten maksymalny znak jest również maksymalną 36 cyfrą podstawową.

Punkt kodowy „0” - „9” to 48–57 , więc musimy odjąć 48 od ich punktów kodowych, aby obliczyć odpowiednie cyfry, lub 47, aby obliczyć najniższą możliwą podstawę. Podobnie punkty kodowe liter „a” - „z” to 97–122 . Ponieważ „a” reprezentuje cyfrę o wartości 10 , musimy odjąć 87 od ich punktów kodowych, aby obliczyć odpowiednie cyfry, lub 86, aby obliczyć najniższą możliwą podstawę. Jednym ze sposobów osiągnięcia tego jest:

Różnica między 97 a 58 ( „:” , znak po „9” ) wynosi 39 , więc biorąc punkty kodowe modulo 39, można osiągnąć odejmowanie. Ponieważ 48% 39 = 9 , a pożądany wynik dla znaku „0” wynosi 1 , najpierw odejmujemy 8, zanim weźmiemy wynik modulo 39 . Odejmowanie w pierwszej kolejności jest konieczne, ponieważ w przeciwnym razie „u”% 39 = 117% 39 = 0 .

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 bajtów

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

Definiuje lambda, która pobiera ciąg x. Znajduje największą cyfrę w ciągu (posortowaną według liter powyżej cyfr, domyślnie w Pythonie) i konwertuje na bazę 36. Dodaje 1, ponieważ 8nie ma jej w bazie 8.

Haskell, 34 bajty

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

Wykorzystuje mod(ord(c)-8,39)pomysł Dennisa.

41 bajtów

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

45 bajtów:

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

Wyjścia jak Just 3.

Cheddar , 34 29 21 bajtów

Zaoszczędzono 8 bajtów dzięki Dennisowi !!!

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

Używa małych liter

Wypróbuj online

Wyjaśnienie

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

05AB1E , 6 bajtów

{¤36ö>

Przyjmuje wielkie litery.

Wyjaśnienie

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

Wypróbuj online

Właściwie 6 bajtów

M6²@¿u

Wypróbuj online!

Julia, 22 bajty

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

Pomiędzy cudzysłowami jest znak BS (0x08). Wypróbuj online!

JavaScript (ES6), 41 37 bajtów

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

Edycja: Zapisano 4 bajty dzięki @ edc65.

Haskell, 55 40 bajtów

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

Dzięki @Dennis za jego podejście. (weź to, @xnor;))

Perl 6: 18 bajtów

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

Definiuje lambda, która pobiera argument z jednym ciągiem i zwraca liczbę całkowitą. Dzieli ciąg na znaki, znajduje „najwyższy”, konwertuje go na bazę 36, dodaje 1.

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

Ten wykorzystuje podejście modulo od Dennisa. Ta sama długość.

Siatkówka , 28 bajtów

O`.
.\B

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

Wypróbuj online! (Pierwszy wiersz włącza pakiet testowy oddzielony od linii).

Wyjaśnienie

O`.

To sortuje znaki wejściowe.

.\B

To usuwa wszystkie postacie oprócz ostatniego, więc pierwsze dwa etapy znajdują maksymalną postać.

{2`
$`
}T01`dl`_o

Są to dwa etapy, które tworzą pętlę. Pierwszy z nich powiela pierwszego znaku, a drugi to „ubytków” (zastępujące np xz w, az 9, a 1z 0). Ten ostatni etap napotyka zero jako pierwszy znak, zamiast tego go usuwa. Jest to standardowa technika generowania zakresu znaków, biorąc pod uwagę górny koniec. W ten sposób generowane są wszystkie „cyfry” od 0cyfry maksymalnej.

.

Wreszcie, po prostu liczymy liczbę cyfr, co daje nam podstawę.

R, 99 89 85 bajtów

Popatrz ! Mniej niż 100 bajtów!
Popatrz ! 10 bajtów off!
Popatrz ! 4 bajty wyłączone!

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

Nie golfowany:

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.

Jak często ta odpowiedź korzysta z ifelsefunkcji:ifelse(Condition, WhatToDoIfTrue, WhatToDoElse)

PHP, 51 38 bajtów

(Od Dennisa) ^^

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

Inna propozycja bez sztuczki Dennisa

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

• Pobiera dane wejściowe jako argument $ argv [1];
• Weź maksymalne wartości znaków (używając ASCII)
• Jeśli jest to liczba (mniejsza niż wartość ascii <a), to należy wypisać liczbę + 1
• W przeciwnym razie wyjściowa wartość ascii -86 (97 dla „a” w ascii, -11 dla „a” jest 11. cyfrą bazową)

Oktawa, 20 bajtów

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

Pyke, 6 bajtów

Seb36h

Wypróbuj tutaj!

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

Java 7, 67 61 bajtów

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

(m-8)%39jest dzięki niesamowitej odpowiedzi @Dennis .

Kod niepoznany i testowy:

Wypróbuj tutaj.

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

Wydajność:

1
7
16
9
5
25
36

C89, 55 53 52 50 bajtów

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

-8%39 bezwstydnie skradziony Dennisowi

Test

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

Wydajność

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

Zaoszczędzono 2 bajty dzięki Toby Speightowi

Zaoszczędzono 2 bajty dzięki Kevinowi Cruijssenowi

C, 55 bajtów

Ta odpowiedź zakłada, że ​​dane wejściowe są w formacie ASCII (lub identyczne z cyframi i literami, np. ISO-8859 lub UTF-8):

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

Po prostu iterujemy wzdłuż łańcucha, pamiętając największą zaobserwowaną wartość, a następnie używamy dobrze znanej konwersji modulo-39 z base- {11..36}.

Program testowy

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

Wyniki testów

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

Mathematica, 34 32 bajty

2 bajty zapisane dzięki Martinowi Enderowi

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

Uznałem, że inna metoda zasługuje na nową odpowiedź.

_{metoda skradziona inspirowana rozwiązaniem Dennisa}

Mathematica, 34 32 bajty

zapisane 2 bajty dzięki Martinowi Enderowi

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

Definiuje czystą funkcję, która pobiera ciąg jako dane wejściowe.

Dzieli dane wejściowe na znaki, konwertuje je na 36 liczb podstawowych i zwraca maksimum +1.

C # REPL, 17 bajtów

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

Właśnie przeniesiono odpowiedź @ Dennisa na C #.

CJam, 10 bajtów

Dzięki Martinowi Enderowi za uratowanie mi kilku bajtów!

Wykorzystuje formułę Dennisa

q:e>8-i39%

Wypróbuj online

CJam, 18 16 bajtów

Alternatywne rozwiązanie:

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

Wypróbuj online

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 bajtów

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

Uruchom to jak:

$ scala whatbase.scala 0123456789abcdefghijklmnopqrstuvwxyz

R, 62 54 bajty

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

Nie golfowany:

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

Aktualizacja: wygolono 8 bajtów z powodu redundancji na.rm=T przy założeniu ważności danych wejściowych.

O 39% większa wielkość w porównaniu do odpowiedzi Frédérica . Poza tym działa trochę szybciej: 0,86 sekundy dla 100000 replikacji w porównaniu do 1,09 sekundy dla konkurencyjnej odpowiedzi. Więc mój jest zarówno mniejszy, jak i bardziej wydajny.

Dyalog APL , 10 bajtów

Monity o wpisywanie wielkich liter.

⌈/⍞⍳⍨⎕D,⎕A

⌈/ maksymalny

⍞ znaki wejściowe

⍳⍨ 1 indeksowane do

⎕D, wszystkie cyfry, po których następuje

⎕A wszystkie postacie

Wypróbuj APL online!

BASH 70

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

Wprowadzane litery są małe.

JavaScript, 57 50 48 bajtów

7 bajtów zapisanych dzięki @ kamaroso97 2 bajty zapisane dzięki @Neil

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

Oryginalna odpowiedź:

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

Perl, 30 27 bajtów

Obejmuje +1 dla -p

Uruchom z wejściem na STDIN, np

base.pl <<< codegolf

base.pl:

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

LiveScript, 32 bajty

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

Część tej odpowiedzi w moim ulubionym języku, która kompiluje się w JavaScript. Gdyby base~numberoperator pracował ze zmiennymi, mógłbym zapisać ->1+36~(it/'')sort!pop!(23 bajty), ale powoduje to konflikt z operatorem powiązania funkcji: /