यह संख्या किस आधार पर है?

31

यहाँ एक आसान चुनौती है:

एक स्ट्रिंग को देखते हुए जो एक अज्ञात आधार में एक संख्या का प्रतिनिधित्व करता है, उस न्यूनतम संभव आधार को निर्धारित करें जो संख्या में हो सकता है। स्ट्रिंग में केवल शामिल होगा 0-9, a-z। यदि आप चाहें, तो आप लोअरकेस के बजाय अपरकेस अक्षर लेना चुन सकते हैं, लेकिन कृपया इसे निर्दिष्ट करें। आपको दशमलव में यह न्यूनतम संभव आधार आउटपुट करना होगा।

यहाँ एक और अधिक ठोस उदाहरण है। यदि इनपुट स्ट्रिंग "01234" थी, तो द्विआधारी में इस संख्या का होना असंभव है, क्योंकि 2, 3, और 4 सभी द्विआधारी में अपरिभाषित हैं। इसी तरह, इस संख्या इसलिए आधार 3, या आधार 4 में नहीं किया जा सकता है, यह संख्या चाहिए ताकि आप चाहिए उत्पादन '5' आधार -5, या एक ऊंचे बेस में हो,।

आपका कोड आधार 1 (एकात्मक, सभी '0) और बेस 36 (' 0-9 'और' ए-जेड ') के बीच किसी भी आधार के लिए काम करना चाहिए।

आप इनपुट ले सकते हैं और किसी भी उचित प्रारूप में आउटपुट प्रदान कर सकते हैं। बेस-कन्वर्जन बिलों की अनुमति है। हमेशा की तरह, मानक खामियां लागू होती हैं, और बाइट्स में सबसे छोटा जवाब विजेता होता है!

परीक्षण IO:

#Input          #Output
00000       --> 1
123456      --> 7
ff          --> 16
4815162342  --> 9
42          --> 5
codegolf    --> 25
0123456789abcdefghijklmnopqrstuvwxyz    --> 36
code-golf  math  base-conversion 
— DJMcMayhem
स्रोत
8
क्या मैं बेस 36 में आउटपुट कर सकता हूं?
— लीक
9
@ लीकन जीज़, मुझे उम्मीद नहीं है।
— डेनिस
4
@LeakyNunYou must output this lowest possible base in decimal.
— DJMcMayhem
3
@ रोहन झुनझुनवाला अगर आपकी भाषाएं एक स्ट्रिंग के सबसे करीब हैं, तो मैं नहीं देखता कि क्यों।
— DJMcMayhem
3
आमतौर पर यूरीरी सभी 1s है, और अग्रणी शून्य किसी भी स्थिति-आधारित संख्यात्मक प्रणाली के लिए मानक नहीं हैं।
— मोनिका

जवाबों:

16

जेली , 4 बाइट्स

ṀØBi

अपरकेस की आवश्यकता है। इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

ṀØ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.
— डेनिस
स्रोत
1
यह वास्तव में 7 बाइट्स है, 4 नहीं। पहले 2 चार्ट बहु-बाइट हैं।
— निकोमक
14
@Nicomak यह उत्तर जेली कोड पृष्ठ में एन्कोड किया गया है , जहां इन सभी पात्रों को प्रत्येक 1 बाइट के रूप में एन्कोड किया गया है।
— लोवजो
26

पायथन, 27 22 बाइट्स

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

इसके लिए इनपुट को बाइटस्ट्रिंग (पायथन 3) या बाईट्रेयर (पायथन 2 और 3) होना चाहिए।

5 बाइट बंद करने के लिए @AleksiTorhamo को धन्यवाद!

Ideone पर इसका परीक्षण करें ।

यह काम किस प्रकार करता है

हम स्ट्रिंग का अधिकतम उपयोग करके शुरू करते हैं। यह अक्षरों के कोड अंक अंकों के कोड बिंदुओं से अधिक है, यह अधिकतम चरित्र भी अधिकतम 36 अंकों का आधार है।

के कोड बिंदु '0' - '9' कर रहे हैं 57 - 48 है, तो हम घटाना चाहिए 48 इसी अंक गणना करने के लिए अपने कोड अंक से, या 47 न्यूनतम संभव आधार गणना करने के लिए। इसी तरह, पत्र के कोड अंक 'एक' - 'z' कर रहे हैं 97 - 122 । चूंकि 'ए' मान 10 के साथ अंक का प्रतिनिधित्व करता है , इसलिए हमें संबंधित अंकों को गणना करने के लिए उनके कोड बिंदुओं से 87 , या सबसे कम संभव आधार की गणना करने के लिए 86 को घटाना होगा । इसे प्राप्त करने का एक तरीका इस प्रकार है।

97 और 58 ( ':' , '9' के बाद का वर्ण ) के बीच का अंतर 39 है , इसलिए कोड अंक मोडुलो 39 लेने से घटाव प्राप्त किया जा सकता है। के बाद से 48% 39 = 9 , और चरित्र के लिए वांछित परिणाम '0' है 1 , हम पहले घटाना 8 परिणाम सापेक्ष लेने से पहले 39 । पहले घटाना आवश्यक है अन्यथा '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
— डेनिस
स्रोत
यदि आप इसे पायथन 3 बनाते हैं, और इनपुट को बाइट स्ट्रिंग के रूप में लेते हैं, तो आप ड्रॉप कर सकते हैं ord()और 3 बाइट जीत सकते हैं । :)
— Aleksi Torhamo
अछा सुझाव! मुझे ओपी से पूछ लेने दो।
— डेनिस
3
@AleksiTorhamo NOOOOOOOOOOOO यू डू
— डिस्क
20

पायथन, 25 बाइट्स

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

एक लैम्ब्डा को परिभाषित करता है जो स्ट्रिंग लेता है x। स्ट्रिंग में सबसे बड़े अंक को ढूँढता है (अजगर के डिफ़ॉल्ट रूप से अंकों के ऊपर क्रमबद्ध), और आधार 36 में कनवर्ट करता है। 1 जोड़ता है, क्योंकि 8आधार 8 में नहीं है।

— Rɪᴋᴇʀ
स्रोत
11

हास्केल, 34 बाइट्स

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

mod(ord(c)-8,39)डेनिस के विचार का उपयोग करता है ।

41 बाइट्स

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

45 बाइट्स:

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

जैसे आउटपुट Just 3।

— XNOR
स्रोत
6

चेडर , 34 29 21 बाइट्स

डेनिस के लिए 8 बाइट्स बचाए !!!

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

लोअरकेस अक्षरों का उपयोग करता है

इसे ऑनलाइन आज़माएं

व्याख्या

s -> (      // Input is `s`
  s.bytes    // Returns array of char codes
   .max      // Get maximum item in array
) % 39      // Modulus 39
— Downgoat
स्रोत
1
या फिर आप सकता है इनपुट के आसपास उद्धरण डाल
— DJMcMayhem
12
@DJMcMayhem .___ मुझे यह भी नहीं पता था कि मेरी खुद की भाषा ऐसा कर सकती है
— डाउनगैट
कैसे के (-)&8बजाय के बारे में n->n-8?
— कॉनर ओ'ब्रायन
@ ConorO'Brien> _> _> _> मैं अभी तक नहीं मिला है। मैं बस इसे करने की योजना बना रहा था और तब यह चुनौती पोस्ट की गई थी। फ़ंक्शन के पहले arg को मूल रूप से f&nबांड n।
— डाउनगेट
@Downgoat ओह। > _>
— कॉनर ओ'ब्रायन
6

05AB1E , 6 बाइट्स

{¤36ö>

ऊपरी मामले में पत्र लेता है।

व्याख्या

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

इसे ऑनलाइन आज़माएं

— Emigna
स्रोत
05AB1E के साथ मेरी भोली को माफ कर दो, लेकिन क्या आपका मतलब है कि 36 से बेस 10 (आधार 10 तक) कन्वर्ट करें?
— कीता
@Keeta आप निश्चित रूप से सही हैं। मेरी गलती।
— एमिगॉन
4

जावास्क्रिप्ट (ईएस 6), 41 37 बाइट्स

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

संपादित करें: सहेजे गए 4 बाइट @ edc65 के लिए धन्यवाद।

— नील
स्रोत
pop()4 को बचाने के लिए उपयोग
— edc65
@ edc65 मैं विश्वास नहीं कर सकता कि जावास्क्रिप्ट युक्तियों के अंतर्गत नहीं है।
— नील
3

हास्केल, 55 40 बाइट्स

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

उनके दृष्टिकोण के लिए धन्यवाद @ डेनिस। (ले कि, @xnor;))

— ThreeFx
स्रोत
मुझे लगता है कि आप f=38 बाइट्स के लिए हटा सकते हैं क्योंकि fस्पष्ट तर्क नहीं लेते हैं।
— 15
3

पर्ल 6: 18 बाइट्स

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

एक लैम्बडा को परिभाषित करता है जो एकल स्ट्रिंग तर्क लेता है, और एक पूर्णांक देता है। यह स्ट्रिंग को वर्णों में विभाजित करता है, "उच्चतम" को पाता है, इसे बेस 36 में परिवर्तित करता है, 1 जोड़ता है।

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

यह एक डेनिस से मोडुलो दृष्टिकोण का उपयोग करता है। एक ही लंबाई।

— SMLS
स्रोत
2

रेटिना , 28 बाइट्स

O`.
.\B

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

इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक लाइनफ़ीड-पृथक परीक्षण सूट को सक्षम करती है।)

व्याख्या

O`.

यह इनपुट के वर्णों को क्रमबद्ध करता है।

.\B

यह अंतिम को छोड़कर सभी वर्णों को हटा देता है, इसलिए पहले दो चरण अधिकतम वर्ण पाते हैं।

{2`
$`
}T01`dl`_o

ये दो चरण हैं जो एक लूप बनाते हैं। पहले एक प्रथम वर्ण और दूसरा एक "decrements" यह (उदाहरण के लिए जगह डुप्लिकेट xके साथ w, aके साथ 9और 1साथ 0)। बाद वाला चरण पहले चरित्र के रूप में एक शून्य का सामना करता है, यह इसके बजाय इसे हटा देता है। यह ऊपरी सीमा को देखते हुए, वर्णों की एक श्रृंखला बनाने के लिए एक मानक तकनीक है। इसलिए, यह सभी "अंक" 0को अधिकतम अंक से उत्पन्न करता है ।

.

अंत में, हम केवल अंकों की संख्या की गणना करते हैं, जो हमें आधार देता है।

— मार्टिन एंडर
स्रोत
2

आर, ९९ 99 ९ 89५ बाइट्स

देखो! 100 से कम बाइट्स!
देखो! 10 बाइट्स!
देखो! 4 बाइट्स!

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

अधूरा:

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.

जैसा कि अक्सर, यह उत्तर ifelseफ़ंक्शन का उपयोग करता है:ifelse(Condition, WhatToDoIfTrue, WhatToDoElse)

— फ़्रेडरिक
स्रोत
मुझे आपके संस्करण से प्यार है; हालाँकि, अक्षरों और संख्याओं को अलग-अलग मानने से उन pesky अतिरिक्त बाइट्स का निर्माण होता है। कृपया मेरे समाधान पर एक नज़र डालें जो एक अलग विधि का उपयोग करता है।
— आंद्रे
आपका जवाब वास्तव में दिलचस्प है। मैं scanकुछ बाइट्स को गोल्फ करने के लिए आपके तरीके का उपयोग करूँगा ;)
— Frédéric
1

PHP, 51 38 बाइट्स

(डेनिस से) ^ ^

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

डेनिस की चाल के बिना अन्य प्रस्ताव

<?=($a=max(str_split($argv[1])))<a?$a+1:ord($a)-86;
  • तर्क $ argv [1] के रूप में इनपुट लेता है;
  • अधिकतम चरित्र (ASCII का उपयोग करके) मान लें
  • यदि यह संख्या है (<a 'ascii मान से हीन) तो आउटपुट संख्या + 1
  • एली आउटपुट एस्की वैल्यू -86 (97 में 'ए' के ​​लिए एस्की, -11 में 'ए' के ​​लिए 11 वाँ डिजिट है)
— क्रिप्टो
स्रोत
यह बहुत बुरा है PHP में ऐसी क्रिया फ़ंक्शन नाम हैं: <?=base_convert(max(str_split($argv[1])),36,10)+1एक सुरुचिपूर्ण समाधान है, लेकिन 49 बाइट्स में!
@YiminRong का उपयोग आप कर सकते हैं जिसके intval()बजाय base_convert()38 बाइट्स तक कम हो जाते हैं <?=intval(max(str_split($argn)),36)+1;tio: tio.run/##K8go@P/…
— 640KB
1

जावा 7, 67 61 बाइट्स

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

(m-8)%39@ डेनिस के अद्भुत उत्तर के लिए धन्यवाद ।

Ungolfed और परीक्षण कोड:

इसे यहाँ आज़माएँ।

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

आउटपुट:

1
7
16
9
5
25
36
— केविन क्रूज़सेन
स्रोत
2
इसके बजाय Math.max()आप का उपयोग कर सकते हैंm = m>c?m:c
— RobAu
@RobAu आह, धन्यवाद। पूरी तरह से इसके बारे में भूल गए .. कभी-कभी मैं जावा में सबसे आसान कोडगॉल्फिंग चीजों को भूल जाता हूं जो कि जावा पोस्ट में कोडगॉर्फ़िंग के लिए युक्तियों में कई बार उल्लेखित हैं । याद दिलाने के लिए शुक्रिया।
— केविन क्रूज़सेन
यदि आप Java 8 पर स्विच करते हैं, तो आप इस पूरे फ़ंक्शन को एक लैम्ब्डा के साथ बदल सकते हैं जो एक सिंगल करता हैreduce
— ब्लूराजा - डैनी पफ्लुगुफ्ट
@ BlueRaja-DannyPflughoeft मुझे पता है, यही वजह है कि मैंने विशेष रूप से जावा 7 के रूप में इसका उल्लेख किया है। जावा 8 लैम्ब्डा को एक अलग उत्तर के रूप में पोस्ट करने के लिए स्वतंत्र महसूस करें।
— केविन क्रूज़सेन
@ BlueRaja-DannyPflughoeft मुझे आश्चर्य है कि अगर कम बाइट के साथ खत्म हो जाएगा ..
— RobAu
1

C89, 55 53 52 50 बाइट्स

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

-8%39 डेनिस से बेशर्मी से चुराया गया

परीक्षा

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

उत्पादन

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

टोबी स्पाइट के लिए 2 बाइट्स का धन्यवाद

केविन क्रूज़सेन के लिए धन्यवाद 2 बाइट्स बचाए

— YSC
स्रोत
आप गैर-प्रोटोटाइप घोषणा के साथ 2 बाइट बचा सकते हैं: f(char*s,int b)बन जाता है f(s,b)char*s;।
— स्पाइट
आप अनावश्यक कोष्ठक और स्थान को हटाकर 3 बाइट्स बचा सकते हैं:f(s,b)char*s;{return*s?f(s+1,*s>b?*s:b):(b-8)%39;}
— केविन क्रूज़सेन
@ केविनक्रूजसेन thx
— YSC
1

सी, 55 बाइट्स

यह उत्तर मानता है कि इनपुट ASCII में है (या संख्याओं और अक्षरों में समान है, जैसे ISO-8859 या UTF-8): 

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

हम बस स्ट्रिंग के साथ पुनरावृति करते हैं, सबसे बड़ा मूल्य देखा गया याद करते हुए, फिर आधार से प्रसिद्ध modulo-39 रूपांतरण का उपयोग करें- {11..36}।

परीक्षण कार्यक्रम

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

परीक्षण के परिणाम

00000 -> 1
123456 -> 7
ff -> 16
4815162342 -> 9
42 -> 5
codegolf -> 25
0123456789abcdefghijklmnopqrstuvwxyz -> 36
— टोबी स्पाईट
स्रोत
क्या आप m = 0 को नहीं निकाल सके? यदि m फ़ाइल के शीर्ष स्तर पर दिखाई देता है, तो इसका बाहरी भाग जो स्थैतिक होता है, जिसका अर्थ है कि इसे शून्य से आरंभ किया गया है।
— बैटमैन
@ बैटमैन - हां, लेकिन केवल तभी जब आप f()एक से अधिक बार कॉल नहीं करेंगे । मुझे पता है कि गोल्फ में लगभग कुछ भी उचित खेल है, लेकिन मेरी पेशेवर प्रवृत्ति बहुत नाजुक है!
— टोबे स्पाइट
आगे सोचने पर, मैं इसे mकॉल के बीच रीसेट करने के लिए एक बाहरी आवश्यकता बना सकता हूं f()। तब मेरा परीक्षण कार्यक्रम अभी भी काम कर सकता था।
— टोबे स्पाइट
@ बैटमैन: कोड गोल्फ मेटा पर, प्रश्न " क्या कार्य प्रस्तुतियाँ पुन: प्रयोज्य हैं? " पर बहुसंख्यक राय एकल-उपयोग कार्यों की अनुमति देने के खिलाफ लगती है। इसलिए मेरे पास वही रहेगा जो मेरे पास है। सुझाव के लिए धन्यवाद, वैसे भी।
— टोबे स्पाइट
1

गणितज्ञ, 34 32 बाइट्स

मार्टिन बायर की बदौलत 2 बाइट बच गईं

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

मैंने तय किया कि अलग विधि एक नए उत्तर की पात्र है।

विधि डेनिस 'समाधान से प्रेरित चोरी

— DanTheMan
स्रोत
2
कुछ उपसर्ग संकेतन का उपयोग करें: Max@Mod[ToCharacterCode@#-8,39]&(वही आपके अन्य उत्तर के लिए जाता है)
— मार्टिन एंडर
2
इसके अलावा, आपको &एक अनाम फ़ंक्शन को इंगित करने के लिए अंत में जोड़ना होगा।
— लीजियनममाल 978
आप @अपने उत्तर ( ToCharacterCode@#और Characters@#) दोनों में से एक को भूल गए ।
— मार्टिन एंडर
1

गणितज्ञ, 34 32 बाइट्स

मार्टिन एंडर के लिए 2 बाइट्स धन्यवाद बचाया

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

एक शुद्ध फ़ंक्शन को परिभाषित करता है जो इनपुट के रूप में एक स्ट्रिंग लेता है।

इनपुट को वर्णों में विभाजित करता है, उन्हें 36 नंबरों के आधार पर परिवर्तित करता है, और अधिकतम +1 देता है।

— DanTheMan
स्रोत
Max@BaseForm[Characters@#,36]+1&
— Alephalpha
1

सी # आरईपीएल, 17 बाइट्स

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

बस # डेनिस के C # के जवाब को चित्रित किया।

— stannius
स्रोत
1

सीजेएम, 10 बाइट्स

मुझे कुछ बाइट्स बचाने के लिए मार्टिन एंडर का धन्यवाद!

डेनिस के सूत्र का उपयोग करता है

q:e>8-i39%

इसे ऑनलाइन आज़माएं

सीजाम, 18 16 बाइट्स

दूसरा तरीका:

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

इसे ऑनलाइन आज़माएं

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
— बिजनेस कैट
स्रोत
1

स्काला, 25 बाइट्स

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

इसे ऐसे चलाएं:

$ scala whatbase.scala 0123456789abcdefghijklmnopqrstuvwxyz

— AmazingDreams
स्रोत
1

आर, 62 54 बाइट्स

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

अद्यतन: na.rm=Tइनपुट वैधता की धारणा के तहत अतिरेक के कारण 8 बाइट्स मुंडा ।

Frédéric के उत्तर की तुलना में आकार में 39% का सुधार । इसके अलावा, यह तेजी से एक मामूली सा दौड़ता है: प्रतिस्पर्धा के उत्तर के लिए 100000 प्रतिकृति बनाम 1.09 सेकंड के लिए 0.86 सेकंड। तो मेरा एक छोटा और अधिक कुशल दोनों है।

— आंद्रे कोस्टीर्का
स्रोत
0

BASH 70

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

इनपुट पत्र लोअरकेस हैं।

— रिले
स्रोत
0

जावास्क्रिप्ट, 57 50 48 बाइट्स

7 बाइट्स ने @Neil की बदौलत @ kamaroso97 2 बाइट्स को बचाया

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

मूल उत्तर:

n=>n.split``.map(a=>parseInt(a,36)).sort((a,b)=>b-a)[0]+1
— DanTheMan
स्रोत
आप 7 बाइट्स के साथ दस्तक दे सकते हैं n=>Math.max(...n.split``.map(a=>parseInt(a,36)+1))।
— kamoroso94
@ kamoroso94 मुझे एहसास नहीं था कि Math.maxअस्तित्व में है। मुझे इसके बारे में बताने के लिए धन्यवाद!
— DanTheMan
[...s]से छोटा है s.split``।
— नील
0

पर्ल, 30 27 बाइट्स

के लिए +1 शामिल है -p

STDIN पर इनपुट के साथ चलाएं, जैसे

base.pl <<< codegolf

base.pl:

#!/usr/bin/perl -p
\@F[unpack"W*"];$_=@F%39-9
— टन हास्पेल
स्रोत
0

लाइवस्क्रिप्ट, 32 बाइट्स

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

मेरी पसंदीदा भाषा में इस उत्तर का एक भाग जो जावास्क्रिप्ट के लिए संकलित है। अगर base~numberऑपरेटर चर के साथ काम करता है तो मैं लिख सकता हूं->1+36~(it/'')sort!pop! (23 बाइट्स), लेकिन यह फ़ंक्शन बाइंड ऑपरेटर के साथ संघर्ष करता है: /

— गुस्तावो रॉड्रिक्स
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.