20

इस चुनौती का उद्देश्य एक इनपुट स्ट्रिंग को लिखने के लिए एक प्रोग्राम लिखना है जिसे केवल अक्षरों और संख्याओं के रूप में माना जा सकता है जिसमें 2 और 36 के बीच के आधार के रूप में कई आधार हो, और परिणामों के आधार 10 योग का पता लगाएं।

इनपुट स्ट्रिंग को सभी आधारों में परिवर्तित किया जाएगा, जिसमें संख्या 36 तक के आधारों के लिए मानक वर्णमाला के अनुसार परिभाषित की जाएगी 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ:। उदाहरण के लिए, इनपुट 2Tकेवल आधार 30 और उसके बाद ही मान्य होगा। कार्यक्रम 36 से दशमलव के आधार पर 2T को 30 से 36 में बदल देगा और परिणामों को योग करेगा।

आप मान सकते हैं कि इनपुट स्ट्रिंग में केवल अक्षर और संख्याएँ हैं। आपका कार्यक्रम अपरकेस या लोअरकेस का उपयोग कर सकता है; यह कर सकता है, लेकिन दोनों का समर्थन करने की आवश्यकता नहीं है।

परीक्षण के मामलों

नमूना इनपुट: 2T

संभावित ठिकानों का चार्ट

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

आउटपुट: 665

नमूना इनपुट: 1012

संभावित ठिकानों का चार्ट:

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

आउटपुट: 444278

नमूना इनपुट: HELLOworld

संभावित ठिकानों का चार्ट

Base   Value
33     809608041709942
34     1058326557132355
35     1372783151310948
36     1767707668033969

आउटपुट: 5008425418187214

के इनपुट को 2 और 36 समावेशी के बीच सभी आधारों के 0रूप 0में पढ़ा जाएगा । आधार 1 जैसी कोई चीज नहीं है।

यह कोड गोल्फ है। मानक नियम लागू होते हैं। बाइट्स में सबसे छोटा कोड जीतता है।

— आर्कटुरस
स्रोत

5

क्या आधार रूपांतरण की अनुमति है?

— lirtosiast

2

महत्वपूर्ण परीक्षण मामला:0

— मार्टिन एंडर

इसे डांग, मैं एक ऐसी ही चुनौती पोस्ट करने जा रहा था।

— DanTheMan

3

@ मार्टिनबटनर 0एक महत्वपूर्ण परीक्षण मामला क्यों है ? 0है 0हर आधार में है, और वहाँ आधार 1. जैसी कोई चीज नहीं है

— आर्कटुरस

3

@ Eridan क्योंकि कुछ भाषाएं आधार 1 से और असफल होने की कोशिश कर रही हैं।

— मार्टिन एंडर

12

पायथन 3, 72 71 69 बाइट्स

एक बाइट को बचाने के लिए FryAmTheEggman को धन्यवाद!

2 बाइट बचाने के लिए DSM को धन्यवाद!

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

— अदनान
स्रोत

@ThomasKwa जो एक शून्य जोड़ देगा, जो विशुद्ध रूप से संख्यात्मक इनपुट के लिए काम नहीं करेगा क्योंकि यह जांचता है कि क्या यह आधार 10 है (जो कुछ परिणाम बहुत बड़ा कर देगा)

— केविन डब्ल्यू।

@FryAmTheEggman धन्यवाद! मैंने इसे समायोजित कर लिया है

— अदनान

बस आपके लिए जाँच की गई। try exceptआप करने देंगे range(37)। दो बाइट्स!

— शर्लक

@ शर्लक 9 यह विशुद्ध रूप से संख्यात्मक इनपुट के लिए काम नहीं करेगा, इनकी व्याख्या आधार 10 नंबरों के रूप में की जाएगी।

— अदनान

अरे ठीक है, डारन @ अदनान

— शर्लक

10

पायथ, 20 19 11 बाइट्स

sm.xizd0S36

अपने पायथन उत्तर से अदनान के विचार को स्पष्ट रूप से चुरा लिया।

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

— orlp
स्रोत

@orlp आप निकाल सकते हैं Sचार

— ब्लू

नहीं। टेस्ट 1012।

— orlp

4

शुद्ध बैश (कोई उपयोगिता नहीं), 38

मान लिया गया कि अंतर्निहित आधार रूपांतरणों की अनुमति है:

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

यह STDERR के लिए एक त्रुटि आउटपुट करेगा। मैं मान रहा हूं कि यह मेटा उत्तर के अनुसार ठीक है ।

परीक्षण उत्पादन:

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

— डिजिटल आघात
स्रोत

3

मैथेमेटिका, 57 बाइट्स

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

— alephalpha
स्रोत

आप के लिए इनफ़िक्स फ़ॉर्म का उपयोग कर सकते हैं FromDigits।

— लीजनमोनमल 978

3

गंभीरता से, 65 बाइट्स

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

इसमें unprintables, hexdump शामिल हैं:

2c963bbb726b6022303132333435363738394142434445464748494a4b4c4d4e4f505152535455565758595a22a175604d53643a33373a407860bda8604de42e7f

दुर्भाग्य से मेरे पास प्रकारों के आधार पर सूची से फ़िल्टर करने का अच्छा तरीका नहीं है। स्वयं पर ध्यान दें: इसे जोड़ें।

जैसे इनपुट लेता है "2T"

इसे ऑनलाइन आज़माएं (आपको मैन्युअल रूप से इनपुट दर्ज करना होगा)

स्पष्टीकरण:

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

— मै जाऊं
स्रोत

शायद गंभीरता से एक कमांड होनी चाहिए जो वर्णमाला और / या संख्या 0-9 पैदा करती है?

— आर्कटिकस

@ Eridan इसे गंभीरता से - सूचकांक को आधा बाइट्स की लागत मिल रही है।

— Mego

2

मतलाब, 98 बाइट्स

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

— लुइस मेंडो
स्रोत

2

ऑक्टेव, 75 73 बाइट्स

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

स्पष्टीकरण:

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

polyvalइसमें एक फायदा base2decहै कि यह सदिश है, इसलिए forलूप की आवश्यकता नहीं है।

केवल '0' .. '9' और अपर-केस 'ए' .. 'जेड' इनपुट के रूप में समर्थित हैं।

— बीकर
स्रोत

वेक्टराइज़ करने के polyvalलिए बहुत चतुर उपयोग !

— लुइस मेंडो डे

1

जाप , 26 बाइट्स

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

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

अपुष्ट और व्याख्या

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

— ETHproductions
स्रोत

1

पायथ, 16 बाइट्स

V36 .x=+ZizhN ;Z

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

explaination:

                 # 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

— अदनान
स्रोत

1

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

1 बाइट बचाने के लिए रेटो कोराडी का धन्यवाद।

यह थोड़े भयानक है ...

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

ऊपरी मामले के पत्रों की आवश्यकता है।

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

CJam में स्ट्रिंग्स से अंतर्निहित बेस -36 रूपांतरण नहीं होता है, इसलिए हमें स्ट्रिंग्स को स्वयं से पत्र करना होगा। मैं सभी प्रकार के दिव्यांग शीनिगन्स की कोशिश कर रहा हूं, लेकिन यह सभी 36 अंकों की एक स्ट्रिंग बनाने के लिए सबसे कम प्रतीत होता है और बस उस स्ट्रिंग में प्रत्येक वर्ण का सूचकांक ढूंढता हूं।

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

q{'0-_9>7*-}%बस के रूप में छोटा है।

— पीटर टेलर

@PeterTaylor ओह, ठीक है ...

— मार्टिन एंडर

1

सी फ़ंक्शन, 93 (केवल 32 बिट पूर्णांक आउटपुट)

आउटपुट के लिए इसके ओके को केवल INT_MAX तक मान लें, तो हम ऐसा कर सकते हैं:

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

अंतिम टेस्टकेस का अर्थ है कि यह संभवतः पर्याप्त नहीं है। यदि ऐसा है, तो हमारे पास 64-बिट पूर्णांक हैं:

सी फ़ंक्शन, 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);}

दुर्भाग्य #include <stdlib.h>से आवश्यक है ताकि वापसी प्रकार strtoll()सही हो। हमें टेस्टकेस long longको संभालने के लिए उपयोग करने की आवश्यकता है HELLOworld। अन्यथा यह काफी कम हो सकता है।

परीक्षण चालक:

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

परीक्षण उत्पादन:

$ ./basesum
0
665
444278
5008425418187214
$

— डिजिटल आघात
स्रोत

C में #include <stdlib.h>आप C ++ में जैसे आप कर सकते हैं वैसा स्पेस हटा सकते हैं ?

— एलेक्स ए।

@AlexA। हाँ - मुझे नहीं पता था कि - धन्यवाद!

— डिजिटल ट्रॉमा

0

पायथन 3, 142 बाइट्स

अदनान ने मुझे उनके समाधान के साथ अच्छी तरह से हराया है, लेकिन मैं अपने स्वयं के प्रयास को जोड़ना चाहता था।

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

यह फ़ंक्शन केवल अपरकेस इनपुट को हैंडल करता है। जोड़े .upper()को for i in s, और यह दोनों अपरकेस और लोअरकेस संभाल लेंगे।

— Sherlock9
स्रोत

0

स्केला 2.11, 93 बाइट्स

यह स्कैला कंसोल पर चलाया जाता है।

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

— जे एटकिन
स्रोत

0

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

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

केवल निचले वर्णों का समर्थन करता है। उपयोग उदाहरण:

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

यह बहुत बड़े पैमाने पर है, क्योंकि मुझे चार-एएससीआईआई और आधार रूपांतरण दोनों को लागू करना होगा। संबंधित पूर्व-परिभाषित फ़ंक्शन मॉड्यूल में होते हैं जिन्हें और भी अधिक महंगे आयात की आवश्यकता होती है।

यह कैसे काम करता है: iएक चरित्र cको इसे अंकों के मूल्य (जैसे i 't'-> 29) में परिवर्तित करता है । fहर संभव आधार के लिए इनपुट स्ट्रिंग के मूल्य की गणना करता है और इसे जमा करता है। आंतरिक लूप का एक गैर-पॉइंटफ़्री संस्करण है map (\base -> foldl1 (\value digit -> value*base + digit) (map i s)) [ ...bases... ]।

— nimi
स्रोत

0

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

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

व्याख्या

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

परीक्षा

कोड स्निपेट दिखाएं

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

स्निपेट का विस्तार करें

— user81655
स्रोत

&&b=v1 बाइट बचाता है ?b=v:0।

— नील

@ नील क्या आपने इसका परीक्षण किया? मुझे पूरा यकीन है कि असाइनमेंट का एक अमान्य बाएं हाथ होगा।

— user81655

क्षमा करें, मैंने इसे दूसरे गोल्फ में इसी तरह के मामले में उलझा दिया।

— नील

0

पर्ल 6 , 35 बाइट्स

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

उपयोग:

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

say code 'HELLOworld' # 5008425418187214

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

say code 'qwertyuiopasdfghjklzxcvbnm1234567890'
# 79495849566202185148466281109757186006261081372450955140

— ब्रैड गिल्बर्ट b2gills
स्रोत

0

सीलोन, 100 96 बाइट्स

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

मैंने पहली बार यह सरल संस्करण केवल 69 बाइट्स लिया था:

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

लेकिन यह पहले टेस्ट के मामले में विफल रहता है, 2000000000665इसके बजाय वापस लौट रहा है 665। ( कारण यह है कि Tमें2T , तेरा रूप में पार्स किया गया है यानी पलता 2 10 ^ 12, साथ मूलांक 10 है जब ) इसलिए हम इस मामले को अलग से पकड़ने के लिए की जरूरत है। _नील_{को धन्यवादऐसा करने का एक अलग तरीका सुझाने जिसने 4 बाइट्स बचाए।}

प्रारूपित:

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

— पाओलो एबरमन
स्रोत

यदि स्ट्रिंग में एक अक्षर है, तो क्या आप शायद आधार 11 से शुरू करके कोड को छोटा कर सकते हैं, इस प्रकार विशेष-केस आधार 10 से बच सकते हैं?

— नील

सभी संभव आधार अभ्यावेदन का योग ज्ञात कीजिए

पायथन 3, 72 71 69 बाइट्स

पायथ, 20 19 11 बाइट्स

शुद्ध बैश (कोई उपयोगिता नहीं), 38

परीक्षण उत्पादन:

मैथेमेटिका, 57 बाइट्स

गंभीरता से, 65 बाइट्स

मतलाब, 98 बाइट्स

ऑक्टेव, 75 73 बाइट्स

स्पष्टीकरण:

जाप , 26 बाइट्स

अपुष्ट और व्याख्या

पायथ, 16 बाइट्स

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

सी फ़ंक्शन, 93 (केवल 32 बिट पूर्णांक आउटपुट)

सी फ़ंक्शन, 122

परीक्षण चालक:

परीक्षण उत्पादन:

पायथन 3, 142 बाइट्स

स्केला 2.11, 93 बाइट्स

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

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

व्याख्या

परीक्षा

पर्ल 6 , 35 बाइट्स

सीलोन, 100 96 बाइट्स