İşte güzel ve kolay bir mücadele:

Bilinmeyen bir tabandaki sayıyı temsil eden bir dize verildiğinde, o sayının olabilecek en düşük kaideyi belirleyin. Dizi yalnızca içerecektir 0-9, a-z. İsterseniz, küçük harf yerine büyük harf almayı seçebilirsiniz, ancak lütfen bunu belirtin. Mümkün olan en düşük bu tabanı ondalık basamağa vermelisiniz.

İşte daha somut bir örnek. Giriş dizesi "01234" ise, bu sayının ikili olması mümkün değildir, çünkü 2, 3 ve 4'ün tümü ikili olarak tanımlanmamıştır. Benzer şekilde, bu nedenle çok sayıda taban 3, ya da baz 4'te olamaz, bu sayı olmalıdır böylece gerektiğini çıkış '5', bir baz-5, ya da daha yüksek bir baz olması.

Kodunuz, taban 1 (tekdüze, tümü '0'lar) ve taban 36 (' 0-9 've' a-z ') arasındaki herhangi bir temel için çalışmalıdır.

Herhangi bir makul formatta girdi alabilir ve çıktı alabilirsiniz. Temel dönüşüm yerleşiklere izin verilir. Her zaman olduğu gibi standart boşluklar geçerlidir ve bayt cinsinden en kısa cevap kazanır!

Test IO:

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

Jöle , 4 bayt

ṀØBi

Büyük harf gerektirir. Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

ṀØ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 bayt

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

Bu, girişin bir bytestring (Python 3) veya bir bytearray (Python 2 ve 3) olmasını gerektirir.

5 byte kapalı golf için @AleksiTorhamo için teşekkürler!

İdeone üzerinde test et .

Nasıl çalışır

En fazla dizeyi alarak başlıyoruz. Bu, harflerin kod noktaları, rakamların kod noktalarından daha yüksektir, bu maksimum karakter aynı zamanda maksimum taban 36 rakamıdır.

Bir kod noktası '0' - '9' vardır 57-48 biz çıkarmak gerekir, böylece 48 karşılık gelen basamak hesaplamak için kendi kod noktalarına ya da 47 mümkün olan en düşük temel hesaplamak için. Benzer bir şekilde, harfler kod noktası 'a' - 'z' olan 97 - 122 . Bu yana , 'a' değeri ile rakam oluşturulacağı 10 biz çıkarmak gerekir 87 karşılık gelen basamak hesaplamak için kendi kod noktalarına ya da 86 mümkün olan en düşük temel hesaplamak için. Bunu başarmanın bir yolu aşağıdaki gibidir.

Arasındaki fark 97 ve 58 ( ':' , sonra karakter '9' ) 'dir 39 , yani kod noktaları modulo alarak 39 çıkarma elde edilebilir. Bu yana % 48 39 = 9 ve karakter için istenen sonuç '0' olan 1 , ilk çıkarma 8 sonuç modulo almadan önce 39 . İlk önce çıkarma işlemi gereklidir çünkü aksi halde '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 bayt

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

İpi alan bir lambda tanımlar x. Dizedeki en büyük basamağı bulur (basamakların üzerindeki harflerle, python'un varsayılan değerine göre sıralanır) ve 36 tabanına dönüştürülür 8.

Haskell, 34 bayt

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

Dennis’ten gelen mod(ord(c)-8,39)fikri kullanır .

41 bayt

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

45 bayt:

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

Çıkışlar gibi Just 3.

Çedar , 34 29 21 bayt

Dennis sayesinde 8 bayt kaydedildi !!!

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

Küçük harf kullanır

Çevrimiçi deneyin

açıklama

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

05AB1E , 6 bayt

{¤36ö>

Harfleri büyük harf alır.

açıklama

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

Çevrimiçi deneyin

Aslında , 6 bayt

M6²@¿u

Çevrimiçi deneyin!

Julia, 22 bayt

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

Tırnak işaretleri arasında bir BS karakteri (0x08) var. Çevrimiçi deneyin!

JavaScript (ES6), 41 37 bayt

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

Düzenleme: @ edc65 sayesinde 4 bayt kaydedildi.

Haskell, 55 40 bayt

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

Yaklaşımı için @Dennis teşekkürler. (şunu al, @xnor;))

Perl 6: 18 bayt

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

Tek bir dize argümanı alan bir lambda tanımlar ve bir tamsayı döndürür. Dizeyi karakterlere böler, "en yüksek" olanı bulur, 36 tabanına dönüştürür, 1 ekler.

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

Bu, Dennis'in modulo yaklaşımını kullanıyor. Aynı uzunluk.

Retina , 28 bayt

O`.
.\B

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

Çevrimiçi deneyin! (İlk satır satır besleme ile ayrılmış bir test takımı sağlar.)

açıklama

O`.

Bu, girişin karakterlerini sıralar.

.\B

Bu, sonuncusu dışındaki tüm karakterleri kaldırır, böylece ilk iki aşama maksimum karakteri bulur.

{2`
$`
}T01`dl`_o

Bunlar bir döngü oluşturan iki aşamadır. İlki ilk karakteri kopyalar ve ikincisi onu "azaltır" (örneğin, xile w, aile 9ve 1ile değiştirerek 0). İkinci aşama, ilk karakter olarak sıfırla karşılaşır, bunun yerine onu kaldırır. Bu, üst uç verilen, bir dizi karakteri üretmek için standart bir tekniktir. Bu nedenle, bu tüm "basamakları" 0maksimum basamaktan oluşturur.

.

Son olarak, bize temel veren basamak sayısını sayarız.

R, 99 89 85 bayt

Bak ! 100 bayttan daha az!
Bak ! 10 bayt kapalı!
Bak ! 4 bayt kapalı!

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.

Sıklıkla, bu cevap ifelsefonksiyondan faydalanır :ifelse(Condition, WhatToDoIfTrue, WhatToDoElse)

PHP, 51 38 bayt

(Dennis'den) ^^

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

Dennis'in hilesi olmadan başka bir teklif

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

• Girdiyi argüman olarak alır $ argv [1];
• Maksimum karakter (ASCII kullanarak) değerlerini al
• Eğer bir sayıysa (<'a' ascii değerinden daha düşük), çıkış numarası + 1
• Başka çıkış ascii değeri -86 (ascii'de 'a' için 97, 'a' için -11, 11. basamaktır)

Oktav, 20 bayt

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

Pyke, 6 bayt

Seb36h

Burada dene!

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

Java 7, 67 61 bayt

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

(m-8)%39@Dennis'in inanılmaz cevabı sayesinde .

Ungolfed ve test kodu:

Burada dene.

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

Çıktı:

1
7
16
9
5
25
36

C89, 55 53 52 50 bayt

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

-8%39 utanmadan Dennis den çalındı

Ölçek

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

Çıktı

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

Toby Speight sayesinde 2 bayt kaydedildi

Kevin Cruijssen sayesinde 2 bayt kaydedildi

C, 55 bayt

Bu cevap, girişin ASCII'de olduğunu (veya rakam ve harflerle aynı olduğunu, örneğin ISO-8859 veya UTF-8) olduğunu varsayar:

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

Basitçe dize boyunca yineliyoruz, görülen en büyük değeri hatırlıyoruz, ardından base- {11..36} 'den iyi bilinen modulo-39 dönüşümünü kullanıyoruz.

Test programı

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

Test sonuçları

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

Mathematica, 34 32 bayt

Martin Ender sayesinde 2 bayt kaydedildi

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

Farklı bir yöntemin yeni bir cevabı hakettiğine karar verdim.

_{yöntem, çalıntı Dennis çözeltisi ilham}

Mathematica, 34 32 bayt

Martin Ender sayesinde 2 bayt kurtardı

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

Bir dizgeyi girdi olarak alan saf işlevi tanımlar.

Girdiyi karakterlere böler, onları baz 36 sayıya dönüştürür ve maksimum +1 değerini döndürür.

C # REPL, 17 bayt

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

Az önce @ Dennis'in C # cevabını taşıyordu.

CJam, 10 bayt

Martin Ender’e beni bir kaç bayt kurtardığı için teşekkürler!

Dennis'in formülünü kullanır

q:e>8-i39%

Çevrimiçi deneyin

CJam, 18 16 btyes

Alternatif çözüm:

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

Çevrimiçi deneyin

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 bayt

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

Gibi koş:

$ scala whatbase.scala 0123456789abcdefghijklmnopqrstuvwxyz

R, 62 54 bayt

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

Güncelleme: na.rm=Tgiriş geçerliliği varsayımının gereğinden fazla olması nedeniyle 8 baytı kapattı .

Frédéric'in cevabına göre boyutta% 39 iyileşme . Bunun yanında, biraz daha hızlı ilerler: 100000 kopya için 0.86 saniye, rakip cevap için 1.09 saniye. Yani benimkilerden biri hem daha küçük hem de daha verimli.

Dyalog APL , 10 bayt

Büyük harf girişi için bilgi istemi.

⌈/⍞⍳⍨⎕D,⎕A

⌈/ maksimum

⍞ giriş karakterleri

⍳⍨ 1 indekslenmiş

⎕D, tüm basamaklar

⎕A bütün karakterler

TryAPL çevrimiçi!

BASH 70

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

Giriş harfleri küçük harflerdir.

JavaScript, 57 50 48 bayt

7 bayt, @ kamaroso97'ye kaydetti 2 bayt @Neil sayesinde kaydedildi

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

Orijinal cevap:

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

Perl, 30 27 bayt

İçin +1 içerir -p

STDIN'deki giriş ile çalıştırın, örn.

base.pl <<< codegolf

base.pl:

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

LiveScript, 32 bayt

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

Bu cevabın portu, JavaScript ile derlenen en sevdiğim dilde. Eğer base~numberoperatör değişkenleri ile çalıştı ben yazabilirim ->1+36~(it/'')sort!pop!(23 bayt), ancak işlev bağlamak operatörü ile çakışan: /