23

इनपुट:
पूर्णांकों की एक सूची / सरणी जिसके लिए प्रत्येक आइटम सीमा में है 2-36।

आउटपुट:
पूर्णांकों का योग (आधार 10 के रूप में), जहां प्रत्येक अगला पूर्णांक पिछले मान के आधार पर होता है (एक नियमित आधार 10 से शुरू होता है)।

उदाहरण:
मान लीजिए कि हमारे पास इस तरह का एक इनपुट है: [4, 12, 34, 20, 14, 6, 25, 13, 33]
फिर हमारे पास एक राशि है:

4    (4  in base-10) +
6    (12 in base-4 ) +
40   (34 in base-12) +
68   (20 in base-34) +
24   (14 in base-20) +
6    (6  in base-14) +
17   (25 in base-6 ) +
28   (13 in base-26) +
42   (33 in base-13)
= 235

गणितीय आधार की व्याख्या की:
मैंने माना कि हर कोई जानता है कि आधार कैसे काम करता है, लेकिन मैं इस बात का एक संक्षिप्त उदाहरण दूंगा कि यह वैसे भी कैसे काम करता है, बस। आइए34 in base-12उदाहरण के लिए लें, हमें कैसे मिला40?

1-34 in regular base-10:
 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34
 So, from 1 to 34 is 34 steps in base-10

1-34 in base-12:
 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 1A, 1B, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 2A, 2B, 30, 31, 32, 33, 34
 So, from 1 to 34 is 40 steps in base-12

यहाँ शायद एक उपयोगी कैलकुलेटर है।

चुनौती नियम:

ऐरे आकार उचित सीमा में होगा (जैसे 1-100/ परीक्षण मामलों को देखें)।
परीक्षण के मामलों में कभी भी पूर्णांक नहीं होंगे जिनमें वर्तमान मान पिछले आधार के लिए अमान्य है (यानी आपके पास कभी ऐसा कुछ नहीं होगा 19 in base-6या 6 in base-6, क्योंकि आधार -6 में केवल अंक होते हैं 0-5)।
आप किसी भी तरह से इनपुट ले सकते हैं। एक अंतर-सरणी के रूप में, अल्पविराम / अंतरिक्ष-पृथक स्ट्रिंग, आदि के रूप में हो सकता है। (आपको अंतर-सरणी को उलटने की अनुमति भी है, जो स्टैक-आधारित प्रोग्रामिंग भाषाओं के लिए उपयोगी हो सकती है।)

सामान्य नियम:

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
कोड-गोल्फ भाषाओं को गैर-गोल्फ भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। किसी भी प्रोग्रामिंग भाषा के लिए यथासंभव कम उत्तर के साथ आने का प्रयास करें।
मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।

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

[4, 12, 34, 20, 14, 6, 25, 13, 33]                            ->   235
 4+ 6+  40+ 68+ 24+ 6+ 17+ 28+ 42

[5, 14, 2, 11, 30, 18]                                        ->   90
 5+ 9+  2+ 3+  33+ 38

[12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 12, 2, 11, 3, 10, 2, 10]    ->   98
 12+ 13+ 11+ 9+ 8+ 7+ 6+ 5+ 4+ 3+ 5+  2+ 3+  3+ 3+  2+ 2

[36, 36]                                                      ->   150
 36+ 114

code-golf math base-conversion

— केविन क्रूज़सेन
स्रोत

1

स्टैक आधारित भाषाओं के लिए जिनके पास LIFO कंटेनर है, क्या इनपुट को उल्टे क्रम में दिया जा सकता है? Dc में मुझे ~ 30 बाइट्स की आवश्यकता होगी ताकि इनपुट में पहला नंबर होने के लिए स्टैक को फ्लिप किया जा सके, जो प्रोसेस किया जाने वाला पहला नंबर हो, जो कि नॉन-स्टैक आधारित भाषाओं में डिफ़ॉल्ट रूप से हो।

— शेषमारा

@seshoumara क्यों नहीं। मैं चुनौती में इसे स्पष्ट करूँगा। यह मुख्य रूप से चुनौती और आउटपुट के बारे में है, और वास्तव में इनपुट-प्रारूप के बारे में नहीं है।

— केविन क्रूज़सेन

4

05AB1E , 7 6 5 बाइट्स

05AB1E एन्कोडिंग का उपयोग करता है ।

केविन क्रूज़सेनš द्वारा सुझाए गए नए बिल्ट-इन का उपयोग करके 1 बाइट को बचाया

TšüöO

व्याख्या

इनपुट सूची को उलट लिया जाता है, जैसा कि चुनौती विनिर्देश द्वारा अनुमति दी गई है।

Tš     # prepend a 10 to the list
  üö   # reduce by conversion to base-10
    O  # sum

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

संशोधित परीक्षण

— Emigna
स्रोत

2

के šबजाए अब बिलिन के साथ 5 बाइट्स हो सकते हैं ¸ì। साथ ही, आपका स्पष्टीकरण " प्रीपेंड " के बजाय " परिशिष्ट " बताता है । :)

— केविन क्रूज़सेन

@ केविनक्रूजसेन: धन्यवाद :)

— एमिग्ना

9

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

lambda a:sum(map(int,map(str,a),[10]+a))

टेस्ट्स आइडोन पर हैं

map(str, a)एक जनरेटर बनाता है, Gयह है कि कॉल strमें प्रत्येक मान पर a, तार को बदलने
map(int, G, [10]+a)एक जनरेटर बनाता है कि कॉल int(g, v)भर जोड़े के लिए Gऔर [10]+a
int(g, v)धर्मान्तरित स्ट्रिंग gपूर्णांक आधार से v(यदि vमें है [2,36]और gमान्य है)
sumक्या यह टिन पर कहते हैं करता है

— जोनाथन एलन
स्रोत

7

पायथन 2, 48 बाइट्स

lambda a:sum(int(`x`,y)for x,y in zip(a,[10]+a))

टेस्ट्स आइडोन पर हैं

zip(a,[10]+a)में मान के जोड़े को पार करता aहै, और पिछले मान या 10पहले के लिए में कॉल परिवर्तित एक स्ट्रिंग के लिए, स्ट्रिंग धर्मान्तरित पूर्णांक आधार से (यदि में है और मान्य है) क्या यह टिन पर कहते हैं करता है
backticksintxs
int(s, y)syy[2,36]s
sum

— जोनाथन एलन
स्रोत

6

पर्ल, 35 34 33 बाइट्स

के लिए +2 शामिल है -ap

STDIN पर संख्याओं की सूची के साथ चलाएँ:

basemix.pl <<< "4 12 34 20 14 6 25 13 33";echo

basemix.pl:

#!/usr/bin/perl -ap
$\+=$&+"$`$& 10"*/.$/*$`for@F}{

मैं इस दुरुपयोग का उपयोग करने का मौका पाने के लिए उम्र का इंतजार कर रहा हूं ...

व्याख्या

इनपुट संख्या में अधिकतम 2 अंक हो सकते हैं। xyआधार में एक नंबर bबस है b*x+y। मैं regex का उपयोग करने जा रहा हूं, /.$/इसलिए पहला अंक अंदर $`और अंतिम अंक समाप्त होता है $&, इसलिए योग में योगदान होता है $&+$b*$`।

मैं इस तथ्य का दुरुपयोग करता हूं कि forरेगेक्स चर (उदाहरण के लिए mapऔर whileकरते हैं) को ठीक से स्थानीय नहीं करता है, इसलिए पिछले लूप में एक मैच के परिणाम अभी भी वर्तमान लूप में उपलब्ध हैं। इसलिए अगर मैं उस आदेश के बारे में सावधान हूं जिसमें मैं संचालन करता हूं तो आधार उपलब्ध है "$`$&", केवल पहले लूप को छोड़कर जहां मुझे आधार की आवश्यकता है 10. मुझे "$`$& 10"इसके बजाय उपयोग करना है

जिस तरह से पहला $&काम एक दुरुपयोग है, क्योंकि यह वास्तव में बदल जाता है /.$/जबकि यह पहले से ही स्टैक पर जोड़ा जा रहा है।

अंतिम गाली }{अंत में होती है जो लूप को बदल देती -pहै

LINE: while (defined($_ = <ARGV>)) {
    ...code..
}
continue {
    die "-p destination: $!\n" unless print $_;
}

सेवा मेरे

LINE: while (defined($_ = <ARGV>)) {
    ...code..
}
{
}
continue {
    die "-p destination: $!\n" unless print $_;
}

कौन सा अर्थ $_प्रिंट में अपरिभाषित होगा, लेकिन यह अभी भी जोड़ता $\है जिसमें मैंने राशि जमा की है। लूप पोस्ट-प्रोसेसिंग प्राप्त करने के लिए यह एक मानक गोल्फ ट्रिक है

— टन हास्पेल
स्रोत

मैं वास्तव में कमजोर पर्ल-फू के साथ हम में से एक के लिए एक स्पष्टीकरण में दिलचस्पी होगी!

— m-chrzan

2

@ m-chrzan सॉल्यूशन निश्चित और स्पष्टीकरण जोड़ा गया

— टोन हास्पेल

4

PHP, 53 51 बाइट्स

for(;$x=$argv[++$i];$b=$x)$s+=intval($x,$b);echo$s;

इनपुट पर इरेटेट करता है, प्रत्येक इनपुट को स्ट्रिंग वैरिएंट में परिवर्तित करता है। फिर आधार के रूप में पिछली संख्या का उपयोग करके पूर्णांक मान लेता है। पहले नंबर के लिए, आधार सेट नहीं किया जाएगा, PHP फिर 10 से शुरू होगी (संख्या प्रारूप से अनुमानित)।

इस तरह से चलाएं ( -dकेवल सौंदर्यशास्त्र के लिए जोड़ा गया):

php -d error_reporting=30709 -r 'for(;$x=$argv[++$i];$b=$x)$s+=intval($x,$b);echo$s;' -- 12 11 10 9 8 7 6 5 4 3 12 2 11 3 10 2 10;echo

बदलाव

वास्तव में, स्ट्रिंग में बदलने की कोई आवश्यकता नहीं है, क्योंकि सीएलआई तर्क पहले से ही स्ट्रिंग हैं। बची 2 बाइट्स।

— aross
स्रोत

3

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

ṙ1DḅṖḌS

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

— डेनिस
स्रोत

3

आप के ṖḌसाथ बदल सकते हैंF

— जोनाथन एलन

4

दुर्भाग्य से, यह पहली संख्या में काम नहीं करेगा दो अंक हैं।

— डेनिस

3

जावा, 86 बाइट्स

s->{int[]b={10};return s.reduce(0,(r,n)->{r+=n.valueOf(""+n,b[0]);b[0]=n;return r;});}

परीक्षण और अपुष्ट

import java.util.function.ToIntFunction;
import java.util.stream.Stream;

public class Main {

  public static void main(String[] args) {
    ToIntFunction<Stream<Integer>> f = s -> {
      int[] b = {10};                 // Base, initialized with 10
      return s.reduce(0, (r, n) -> {  // Typical use of reduction, sum starts with 0.
        r += n.valueOf("" + n, b[0]); // Add the value in the previous base.
        b[0] = n;                     // Assign the new base;
        return r;
      });
    };

    System.out.println(f.applyAsInt(Stream.of(new Integer[]{4, 12, 34, 20, 14, 6, 25, 13, 33})));
  }
}

— ओलिवियर ग्रेजायर
स्रोत

3

जावास्क्रिप्ट ईएस 6, 45 42 41 बाइट्स

const g =
     a=>a.map(v=>s+=parseInt(v,p,p=v),s=p=0)|s
;

console.log(g.toString().length);                                            // 42
console.log(g([4, 12, 34, 20, 14, 6, 25, 13, 33]));                          // 235
console.log(g([5, 14, 2, 11, 30, 18]  ));                                    // 90
console.log(g([12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 12, 2, 11, 3, 10, 2, 10] )); // 98

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

यथाशक्ति parseInt(x,0) === parseInt(x,10)।

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

— Lmis
स्रोत

अच्छा! मुझे लगता है कि आप को बदल कर एक बाइट बचा सकता है &&sके साथ |s।

— ETHproductions

तुम भी const gबस के साथ बदल सकते हैंg

— क्लाइड लोबो

3

शुद्ध बैश, ३ 38

b=10
for i;{((t+=$b#$i,b=i));}
echo $t

इनपुट सूची कमांड-लाइन पर दी गई है। for i;स्वचालित रूप से इनपुट मापदंडों (इसके बराबर for i in $@;) से अधिक पुनरावृत्त होता है ।

Ideone।

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

3

जावा 7, 109 89 86 बाइट्स

int c(int[]a){for(Byte i=1;i<a.length;a[0]+=i.valueOf(a[i]+"",a[++i-2]));return a[0];}

करने के लिए golfed 20 बाइट धन्यवाद @cliffroot (एक मूर्ख गलती की वजह से है जो 12 की मैं अपने आप को बनाया)।

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

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

class M{
  static int c(int[] a){
     for(Byte i = 1; i < a.length; a[0] += i.valueOf(a[i]+"", a[++i-2]));
     return a[0];
  }

  public static void main(String[] a){
    System.out.println(c(new int[]{ 4, 12, 34, 20, 14, 6, 25, 13, 33 }));
    System.out.println(c(new int[]{ 5, 14, 2, 11, 30, 18 }));
    System.out.println(c(new int[]{ 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 12, 2, 11, 3, 10, 2, 10 }));
    System.out.println(c(new int[]{ 36, 36 }));
  }
}

आउटपुट:

— केविन क्रूज़सेन
स्रोत

क्या आपको वास्तव में जरूरत है p? योग की गणना इस तरह की जा सकती है, क्या यह नहीं है r+=r.valueOf(""+a[i],a[i-1]):?

— ओलिवियर ग्रेगोइरे

1

+""इसके बजाय रूपांतरण का इस्तेमाल किया valueOfऔर अनावश्यक चरों को हटा दिया -int c(int[]a){for(Integer i=1;i<a.length;a[0]+=i.valueOf(a[i]+"",a[++i-2]));return a[0];}

— cliffroot

@cliffroot आह, मैं एक बेवकूफ हूँ .. जब मैं परीक्षण कर रहा था तो मैंने एक गलती की 10और pउलट दिया था। मैंने गलती का एहसास किया और इसे ठीक कर दिया, लेकिन चूंकि स्ट्रिंग भाग अब नियमित आधार -10 है इसलिए मैं वास्तव में इसे हटा सकता हूं toStringऔर उपयोग कर सकता हूं +"".. धन्यवाद, और अन्य चीजों को गोल्फ के लिए भी धन्यवाद, -20 बाइट्स। मैं वास्तव में एक जवाब दे सकता हूं कि आप अधिक गोल्फ नहीं कर सकते हैं (ऐसा नहीं है कि मैं इसकी सराहना नहीं करता हूं! छोटे कोर्स की बेहतर है - कोड-गोल्फिंग में वह है पी।)

— केविन क्रूज़सेन

बस मेरे जवाब के साथ तुलना करने के लिए, आपका वर्तमान जावा के सिंटैक्स में 79 बाइट्स लंबा है (मेरा वर्तमान में 86 बाइट्स लंबा है)। लेकिन यह दूसरों के कोड लेने में मज़ा नहीं है;)

— ओलिवियर ग्रेजायर

1

@ केविनक्रूजसेन, मैं इसके साथ ठीक से अधिक हूं :) मुझे बस लगता है कि वास्तविक रूप से जावा उस सभी 5-6 बाइट्स समाधान के साथ प्रतिस्पर्धा नहीं करता है, इसलिए मैं अक्सर अपने स्वयं के उत्तर नहीं जोड़ता हूं, लेकिन मुझे अभी भी गोल्फ का मज़ा मिल रहा है दूसरों के समाधान के नीचे।

— क्लिफरॉट

2

दरअसल, 12 बाइट्स

;p(dX(♂$♀¿Σ+

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

स्पष्टीकरण:

;p(dX(♂$♀¿Σ+
;             dupe input
 p            pop first element from list
  (dX         pop and discard last element from other copy
     (♂$      stringify all elements in first copy
        ♀¿    for each pair of elements in the two lists, interpret the first element as a base-(second element) integer
          Σ   sum
           +  add first element of original list

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

2

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

l~{A\:A10bb}%:+

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

व्याख्या

l~     e# Read and evaluate input.
{      e# Map this block over the input...
  A    e#   Push A. Initially this is 10, afterwards it will be the value of the
       e#   last iteration.
  \:A  e#   Swap with current value and store that in A for the next iteration.
  10b  e#   Convert to base 10 to get its decimal digits.
  b    e#   Interpret those in the base of the previous A.
}%
:+     e# Sum all of those values.

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

2

हास्केल, 65 59 बाइट्स

b%x|x<1=x|y<-div x 10=b*b%y+x-10*y
sum.((10:)>>=zipWith(%))

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

— डेमियन
स्रोत

2

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

बहुत रचनात्मक समाधान नहीं है, लेकिन यहाँ यह है:

function[s]=r(x);j=10;s=0;for(i=x)s=s+base2dec(num2str(i),j);j=i;end

टेस्ट:

>> r([4,12,34,20,14,6,25,13,33])
ans =
   235
>> r([12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 12, 2, 11, 3, 10, 2, 10])
ans =
   98
>> r([5, 14, 2, 11, 30, 18])
ans =
   90
>> r([36,36])
ans =
   150

— ptev
स्रोत

आप एक बाइटfunction s=r(x);...

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

2

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

मैंने एक पुनरावर्ती दृष्टिकोण का उपयोग किया।

f=([b,...a],c)=>b?parseInt(b,c)+f(a,b):0

6 बाइट्स बचाए, ल्मिस को धन्यवाद!
बच गया 8 और बाइट्स, नील की बदौलत!

— Huntro
स्रोत

1

मुझे लगता है कि आप 3 बाइट्स का उपयोग करके बचा सकते parseInt(a,b)हैं parseInt(a[0],b)क्योंकि parseIntपहले तर्क को स्ट्रिंग में कनवर्ट करता है और पहले अमान्य वर्ण (यानी ',') पर शुरू होने वाली सभी चीजों को अनदेखा करता है।

— लेमिस

1

मुझे भी लगता है कि आप a[0]?stuff():0इसके बजाय कुछ बाइट्स बचा सकते हैंa.length&&stuff()

— Lmis

@ लमिस थैंक्स, मैंने इसे अपडेट किया है :)

— हंट्रो सेप्ट

1

मुझे लगता है कि आप इसे 40 बाइट्स तक छोटा कर सकते हैं:f=([b,...a],c)=>b?parseInt(b,c)+f(a,b):0

— नील

@ sliceसमारोह का उपयोग न करने का अच्छा तरीका है

— हंट्रो

2

पर्ल 6 , 52 50 बाइट्स

{sum (10,|@_).rotor(2=>-1).map:{+":{.[0]}<{.[1]}>"}}
{sum (10,|@_).rotor(2=>-1).map:{":{.[0]}<$_[1]>"}}

स्पष्टीकरण:

# bare block lambda with implicit parameter ｢@_｣
{
  sum

    ( 10, |@_ )        # the input with a preceding 10
    .rotor( 2 => -1 )  # grab 2 values, back up one, repeat
    .map:
    {
      # create a string of the form ":10<4>"
      ":{
        .[0]            # first element from $_
      }<{
        .[1]            # second element from $_
      }>"
    }
}

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

1

पायथन 2, 52 बाइट्स

f=lambda x:x[1:]and int(`x.pop()`,x[-1])+f(x)or x[0]

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

— डेनिस
स्रोत

1

जूलिया, 63 बाइट्स

f(l)=sum([parse(Int,string(l[i]),l[i-1])for i=2:length(l)])+l[]

प्रत्येक तत्व को (पहले को छोड़कर) पिछले तत्व को आधार और रकम के रूप में लेना। पहले तत्व को अंत में जोड़ता है

— nyro_0
स्रोत

1

रूबी, 52 बाइट्स

->a{eval a.zip([10]+a).map{|e|'"%s".to_i(%s)'%e}*?+}

ungolfed

->a{
  eval(
    a.zip([10]+a).map { |e|
      '"%s".to_i(%s)' % e
    }.join("+")
  )
}

प्रयोग

f=->a{eval a.zip([10]+a).map{|e|'"%s".to_i(%s)'%e}*?+}
p f[[4, 12, 34, 20, 14, 6, 25, 13, 33]] # => 235

— cia_rana
स्रोत

1

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

def f(a:Int*)=a zip(10+:a)map{t=>Integer.parseInt(""+t._1,t._2)}sum

स्पष्टीकरण:

def f(a: Int*) =     //declare a method f with varargs of type Int as parameter
a zip (10 +: a)      //zip a with 10 prepended to a, resulting in...
                     //...Array((4,10), (12,4), (34,12), (20,34), (14,20), (6,14), (25,6), (13,25), (33,13))
map { t =>           //map each tuple t to...
  Integer.parseInt(  //...an integer by parsing...
    ""+t._1, t._2    //...a string of the first item in base-second-item.
  )
}
sum                  //and sum

— corvus_192
स्रोत

1

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

काश मैथमेटिका के फंक्शन के नाम छोटे होते। लेकिन अन्यथा मैं खुश हूं।

Tr[FromDigits@@@Transpose@{IntegerDigits/@{##,0},{10,##}}]&

उदाहरण के लिए,

Tr[FromDigits@@@Transpose@{IntegerDigits/@{##,0},{10,##}}]&[4,12,34,20,14,6,25,13,33]

पैदावार 235।

{##,0}इनपुट युक्तियों की एक सूची है, जिसमें 0 (अंकों का प्रतिनिधित्व) जोड़ा गया है; {10,##}10 पूर्वसर्ग (आधारों का प्रतिनिधित्व) के साथ इनपुट तर्कों की एक सूची है। सूचियों की यह जोड़ी Transposeप्रत्येक को अपने आधार के साथ अंक के साथ जोड़ने के लिए घ है, और FromDigits(yay!) प्रत्येक अंक-आधार जोड़ी को आधार -10 पूर्णांक में परिवर्तित करती है, जिसके परिणाम संक्षेप में बताए गए हैं Tr।

— ग्रेग मार्टिन
स्रोत

1

आम लिस्प, 83

(lambda(s)(loop for b ="10"then x for x in s sum(#1=parse-integer x :radix(#1#b))))

विवरण

(defun base-mix (list)
  (loop
     for base = "10" then string
     for string in list
     sum (parse-integer string :radix (parse-integer base))))

loopनिर्माण स्वीकार करता है "w तो वी" यात्रा निर्माणों, जहां वी एक अभिव्यक्ति पहली बार यात्रा चर गणना की जाती है मूल्यांकन किया जाना है, और w अभिव्यक्ति लगातार पुनरावृत्तियों के लिए मूल्यांकन किया जाना है। घोषणाओं का मूल्यांकन एक के बाद एक किया baseजाता है , इसलिए पहले "10" है, फिर stringसूची के पिछले तत्व को listपुनरावृत्त किया जाता है। sumकीवर्ड राशि की गणना करता है: पूर्णांक से पढ़ने के stringआधार के साथ ख , जहां ख पूर्णांक से पार्स है baseआधार 10 में स्ट्रिंग, #1=और #1#परिभाषित करने के लिए अंकन और उपयोग कर रहे हैं पाठक चर: पहले एक चर के लिए एक एस-अभिव्यक्ति को प्रभावित करता है, अन्य एक ही वस्तु द्वारा संदर्भ को बदलता है। यह लंबे नामों के लिए कुछ वर्ण सहेजता है।

उदाहरण

(base-mix '("4" "12" "34" "20" "14" "6" "25" "13" "33"))
=> 235

— कोर निपात
स्रोत

1

जाप `-x` , 7 बाइट्स

äÏsnX}A

कोशिश करो

äÏsnX}A     :Implicit input of array
ä           :Take each consecutive pair of elements
 Ï          :Pass them through the following function as X & Y
  s         :  Convert Y to a base-10 string
   nX       :  Convert to an integer from base-X
     }      :End function
      A     :Before doing any of that, though, prepend 10 to the array
            :Implicit output of the sum of the resulting array

— झबरा
स्रोत

मिश्रण में बेस

05AB1E , 7 6 5 बाइट्स

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

पायथन 2, 48 बाइट्स

पर्ल, 35 34 33 बाइट्स

व्याख्या

PHP, 53 51 बाइट्स

बदलाव

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

जावा, 86 बाइट्स

परीक्षण और अपुष्ट

जावास्क्रिप्ट ईएस 6, 45 42 41 बाइट्स

शुद्ध बैश, ३ 38

जावा 7, 109 89 86 बाइट्स

दरअसल, 12 बाइट्स

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

व्याख्या

हास्केल, 65 59 बाइट्स

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

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

पर्ल 6 , 52 50 बाइट्स

स्पष्टीकरण:

पायथन 2, 52 बाइट्स

जूलिया, 63 बाइट्स

रूबी, 52 बाइट्स

ungolfed

प्रयोग

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

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

आम लिस्प, 83

विवरण

उदाहरण

जाप -x , 7 बाइट्स

जाप `-x` , 7 बाइट्स