आईएसबीएन -13 को आईएसबीएन -10 में परिवर्तित करना

Question

परिचय

इस चुनौती में आपका कार्य आईएसबीएन -१३ कोड दिए गए पुस्तकों के लिए आईएसबीएन -१० कोड तैयार करना है, यह मानते हुए कि ऐसा कोड मौजूद है। इस तरह के आईएसबीएन -13 कोड में कई भागों को अलग किया जाता है -:

978-GG-PPPP-TTT-C

अक्षर G(समूह), P(प्रकाशक), T(शीर्षक) और C(चेकसम) सभी एक अंक के लिए खड़े होते हैं। इस चुनौती के उद्देश्य के लिए समूहीकरण और C( इस चुनौती को देखें ) की गणना दिलचस्प नहीं है और हम इस कार्य को सरल बनाने के लिए सभी हाइफ़न को छोड़ देंगे।

एक आईएसबीएन -10 नंबर में एक समान लेआउट है:

GG-PPPP-TTT-c

अक्षर G, Pऔर T13 अंकों के आईएसबीएन के लिए समान हैं, हालांकि cअलग है (और एक अलग एल्गोरिथ्म का उपयोग करके गणना की जाती है)। अंक cको इस तरह से चुना जाता है जैसे कि निम्नलिखित समतुल्य धारण (अंक क्रम में):

10*G + 9*G + 8*P + … + 3*T + 2*T + 1*c = 0 (mod 11)

उदाहरण

आइए हम आईएसबीएन संख्या पर विचार करें 9780345391803: अपने संबंधित आईएसबीएन -10 कोड को प्राप्त करने के लिए हम बस अग्रणी 978और चेकसम को छोड़ 3देते हैं 034539180।

अगला हमें नई चेकसम गणना करने की आवश्यकता है:

10*0 + 9*3 + 8*4 + 7*5 + 6*3 + 5*9 + 4*1 + 3*8 + 2*0 = 185

अगला नंबर विभाज्य 11है 187, इसलिए नया चेकसम है 2और इस प्रकार आईएसबीएन -10 कोड है 0345391802।

नियम

• आपके इनपुट में हमेशा आईएसबीएन -10 नंबर होगा (यानी यह ठीक 13 अंकों का लंबा है और इसके साथ शुरू होता है 978)
• इनपुट के लिए जरूरी नहीं है कि वह एक मान्य आईएसबीएन -13 (उदाहरण के लिए 9780000000002) हो ।
• आपको गारंटी है कि परिणामी आईएसबीएन के साथ समाप्त नहीं होगा X
• आप एक पूर्णांक या स्ट्रिंग के रूप में (हाइफ़न के साथ या बिना) इनपुट ले सकते हैं, हालांकि अंकों की एक पूर्व-सूचीबद्ध सूची की अनुमति नहीं है
• आपका आउटपुट एक मान्य ISBN-10 नंबर होना चाहिए (हाइफ़न के साथ या बिना)
• आपका आउटपुट पूर्णांक या स्ट्रिंग (फिर से अंकों की कोई सूची नहीं) हो सकता है

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

9780000000002 -> 0000000000
9780201882957 -> 0201882957
9781420951301 -> 1420951300
9780452284234 -> 0452284236
9781292101767 -> 1292101768
9780345391803 -> 0345391802

_{प्रमुख शून्य पर ध्यान दें!}

Comments

यह सभी पर समाधानों को प्रभावित नहीं करता है, लेकिन सिर्फ उस लड़के के होने के लिए, एक आईएसबीएन (या -10 या -13) के हिस्सों को अलग करने का आपका वर्णन गलत है। पंजीकरण समूह तत्व चर लंबाई है, और बाद के भागों के लिए अंकों की संख्या के बीच और पंजीकरण समूहों के बीच भिन्न हो सकते हैं। उदाहरण के लिए, दोनों में 0-684-84328-5और 99921-58-10-7, पहला भाग ( 0और 99921क्रमशः) पंजीकरण समूह है, दूसरा भाग प्रकाशक है, और इसी तरह।

— जॉर्डन

10/10 नमूना आईएसबीएन विकल्प

— जैकब

Answer 1

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

>,L3,-2`.+
.
$.>`**
_{11}

_

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

व्याख्या

रेटिना की कुछ नई विशेषताओं को दिखाने का समय। :)

>,L3,-2`.+

हम पूरे इनपुट के साथ .+मिलान करते हैं L, उस मैच को वापस करते हैं , लेकिन केवल वर्ण 3 (शून्य-आधारित) से -2 (पेनॉल्मेट), समावेशी का चयन करते हैं। हम एक अनुगामी लाइनफीड ( >) के बिना भी परिणाम प्रिंट करते हैं ।

अब, रेटिना में चीजों को घटाना थोड़ा कष्टप्रद है। लेकिन सौभाग्य से, हम modulo 11 काम कर रहे हैं, इसलिए हम रैखिक संयोजन (mod 11) के गुणांक को उल्टा कर सकते हैं और सब कुछ जोड़ सकते हैं। दूसरे शब्दों में, यदि बाधा है:

10*G + 9*G + 8*P + … + 3*T + 2*T + 1*c = 0 (mod 11)

तब हमें मिलता है:

c = 1*G + 2*G + 3*P + … + 8*T + 9*T (mod 11)

यह चीजों को बहुत सरल बनाता है:

.
$.>`**

हम प्रत्येक पात्र को नीचे की ओर उस चीज़ से प्रतिस्थापित करते हैं। *रेटिना का पुनरावृत्ति ऑपरेटर है। यह सही-सहयोगी है और इसमें $&बाईं ओर और _दाईं ओर अंतर्निहित ऑपरेंड हैं , इसलिए प्रतिस्थापन वास्तव में कम है $.>`*$&*_। d अंडरस्कोर $&*_का एक स्ट्रिंग बनाता है , जहां d वह अंक है जो हम वर्तमान में बदल रहे हैं। फिर मैच तक स्ट्रिंग की लंबाई और शामिल है। ¹ इसलिए, संपूर्ण अभिव्यक्ति का परिणाम हमारे रैखिक संयोजन के n वें कार्यकाल की एकात्मक प्रतिनिधित्व है ।$.>`

_{11}

वास्तविक मोडुलो करना एकात्मक में तुच्छ है: हम सिर्फ 11 अंडरस्कोर के सभी पूर्ण सेट छोड़ देते हैं।

_

अंत में, हम गिनते हैं कि कितने अंडरस्कोर बने हुए हैं और परिणाम को प्रिंट करते हैं, जो आईएसबीएन -10 पूरा करता है।

---

¹ कैसे $.>`और मैच सहित स्ट्रिंग की लंबाई देता है? आप $`रेगेक्स प्रतिस्थापन में परिचित हो सकते हैं , जो आपको मैच के लिए स्ट्रिंग (लेकिन बाहर करने) तक देता है। एक डालने से >, हम के संदर्भ बदल सकते हैं $`करने के लिए विभाजक वर्तमान मैच और अगले (जो वर्तमान अंकों और अगले के बीच कोई रिक्त स्ट्रिंग है) के बीच। उस विभाजक के $`वर्तमान मैच में शामिल होगा। तो $>`लिखने का एक छोटा तरीका है $`$&। अंत में, सभी $xप्रकार के प्रतिस्थापन तत्वों के लिए, रेटिना आपको इसकी लंबाई प्राप्त करने के .बाद सम्मिलित करने देता है $।

Comments

इस modulo 11 जादू क्या है ?! वह मुझे 4 बाइट्स बचा लेगा ... लेकिन मैं नहीं मिलता!

— स्ट्रीटस्टर

@streetster मूल रूप से, -2 ≡ 9 (mod 11)(क्योंकि किसी संख्या से 11 को जोड़ना या घटाना सर्वांगसम वर्ग mod 11 में इसका "मान" नहीं बदलता है)। और इसके अलावा और गुणा गुणांक वर्गों का सम्मान करता है, इसलिए आप किसी भी मूल्य को रैखिक संयोजन में वर्तमान मॉडुलो के तहत एक समान मूल्य के साथ बदल सकते हैं। मैं नकारात्मक संख्या के बारे में बात कर रहा हूँ वास्तव में सिर्फ इतना है कि मैंने समीकरण को cएक तरफ और अन्य सभी शब्दों को (नकारात्मक के रूप में) दूसरे पर पुन: व्यवस्थित किया है ।

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

मुझे लगता है कि मैं इसे अभी प्राप्त करता हूं। इसलिए आप cबनने के लिए आगे बढ़ते हैं -c = ...और 10 9 8...आपके द्वारा गुणा करने के बजाय 11प्रत्येक से घटाते हैं -1 -2 -3...और फिर पाने के लिए सब कुछ -1 से गुणा करते हैं c।

— स्ट्रीटस्टर

क्या आप यह समझाते हैं कि अंतिम चरण केवल अनुगामी अंडरस्कोर की जगह क्यों ले रहा है? मैंने कुछ समय बिताया है जो यह पता लगाने की कोशिश कर रहा है कि क्या कारण है लेकिन मैं इसे पुन: पेश नहीं कर सकता। इस अद्यतन को आश्चर्यजनक लगता है, अच्छा काम!

— FryAmTheEggman

@FryAmTheEggman धन्यवाद :) उस बिंदु पर, स्ट्रिंग में केवल अंडरस्कोर होते हैं। हमने पहले चरण में पहले नौ अंक छपवाए हैं।

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

Answer 2

05AB1E , 17 15 13 12 बाइट्स

¦¦¦¨DSƶO11%«

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

व्याख्या

¦¦¦            # remove the first 3 characters
   ¨           # remove the last character
    D          # duplicate
     S         # split to list of digits
      ƶ        # multiply each by its 1-based index
       O       # sum
        11%    # mod by 11
           «   # concatenate

Answer 3

पॉवरशेल , 96 84 बाइट्स

$y=-(([char[]]($x="$args"-replace'^978|.$')|%{--$a*[int]"$_"})-join'+'|iex)%11;$x+$y

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

इनपुट लेता है "$args", -replaceकेवल पुर्जों को प्राप्त करने के लिए एक रेगेक्स करता है , जो $xएक स्ट्रिंग के रूप में संग्रहीत करता है । फिर हमने उसे charप्रत्येक अक्षर के माध्यम से -अरे और लूप के रूप में डाला। लूप के अंदर, हम पूर्व-अपघटन $a(जो चूक करते हैं 0) और चेकसम गणना के अनुसार गुणा करते हैं। कलाकारों को नोट करें int, अन्यथा यह ASCII मूल्यों का उपयोग करेगा।

हम फिर -joinउन नंबरों के साथ +और पाइप के साथ iex( Invoke-Expressionऔर इसी तरह eval)। हम %11उस चेकसम को लेते हैं और स्टोर करते हैं $y। अंत में, हम कंसट्रेट को स्ट्रिंग करते हैं $x + $y, और पाइप लाइन पर छोड़ देते हैं। आउटपुट निहित है।

Emigna के लिए धन्यवाद 12 बाइट्स सहेजे गए।

Comments

मैं वास्तव में powershell पता नहीं है, लेकिन मुझे लगता है की तरह कुछ इस 84 के लिए काम कर सकते हैं

— Emigna

@Eigna हाँ, बिल्कुल। मापांक अंकगणित और मेरा दिमाग अच्छी तरह से नहीं खेलता है।

— AdmBorkBork

Answer 4

ऑक्टेव , 46 41 39 37 बाइट्स

@(a)[c=a(4:12) 48+mod(7+c*(1:9)',11)]

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

कोड एक स्ट्रिंग के रूप में इनपुट लेता है, और एक स्ट्रिंग लौटाता है।

कोड निम्नानुसार टूट जाता है:

@(a) एक अनाम फ़ंक्शन बनाता है।

[c=a(4:12) ... ]हम मुख्य कोड बनाने वाले पात्रों को निकालने के साथ , cबाद में उपयोग के लिए एक प्रतिलिपि सहेजते हैं, और अंतिम आउटपुट स्ट्रिंग में एक और प्रतिलिपि जोड़ते हैं।

पर @ अदला-बदली की MartinEnter के चालाक रास्ता के आधार 10:-1:2में 1:10, हम आसानी से कि सीमा पैदा करते हैं और यह स्थानांतरित एक स्तंभ वेक्टर प्राप्त करने के लिए कर सकते हैं। c*(1:10)'पंक्ति वेक्टर cऔर श्रेणी स्तंभ वेक्टर की सरणी गुणा करता है । यह एक तत्व-वार गुणा करने के बराबर है फिर योग।

चेकसम सामान्य रूप mod(11-sum,11)से 11. के गुणक के लिए आवश्यक संख्या की गणना करेगा। हालाँकि, क्योंकि cएक चरित्र स्ट्रिंग था, योग वास्तव में 2592 (48 * 54) से बड़ा होना चाहिए क्योंकि हम संख्याओं से गुणा करते हैं यह वास्तविक मूल्य से 48 बड़ा था।

जब हम मोडुलो प्रदर्शन करते हैं, तो यह स्वचालित रूप से 2592 के सभी लेकिन 7 से छुटकारा पा जाएगा। इस तरह, और सीमा की उपेक्षा के लिए लेखांकन, वास्तविक गणना बन जाता है 48+mod(7+sum,11)। हम ASCII वर्ण में वापस कनवर्ट करने के लिए परिणाम में 48 जोड़ते हैं।

चेकसम वर्ण परिणाम के अंत में जोड़ा जाता है, और मूल्य वापस आ गया।

Answer 5

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

ṫ4ṖȮV€xJS%11

यह एक पूर्ण प्रोग्राम है जो I / O के लिए स्ट्रिंग्स का उपयोग करता है।

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

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

ṫ4ṖȮV€xJS%11  Main link. Argument: s (string of length 13)

ṫ4            Tail 4; discard the first three characters.
  Ṗ           Pop; discard the last characters.
   Ȯ          Output; print the result to STDOUT and return it.
    V€        Eval each; turn digit characters into digits.
       J      Indices; yield [1, ..., 13].
      x       Repeat the first digit once, the second digit twice, etc.
        S%11  Take the sum, modulo 11.
              (implicit) Print the checksum to STDOUT.

Answer 6

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

s=>(s=s.slice(3,-1))+[...s].reduce(n=>n+s[i++]*i,i=0)%11

f=
s=>(s=s.slice(3,-1))+[...s].reduce(n=>n+s[i++]*i,i=0)%11
//s=>(s=s.slice(3,-1))+(n=0,[...s].map((c,i)=>n+=c*-~i),n)%11
//s=>(s=s.slice(3,-1))+(n=0,[...s].map(c=>n+=c*i++,i=1),n)%11
//s=>(n=0,[...(s=s.slice(3,-1))].map((c,i)=>n+=c*-~i),s+n%11)
//s=>(s=s.slice(3,-1,n=i=0))+eval(`for(c of s)n+=c*-~i++`)%11

console.log(...[
  '9780000000002',
  '9780201882957',
  '9781420951301',
  '9780452284234',
  '9781292101767',
  '9780345391803'
].map(f))

-3 बाइट्स @ शैगी के सुझाव के लिए धन्यवाद ।

Comments

57 बाइट्स ?

— झबरा

या शायद 56 बाइट्स भी ।

— झबरा

तो क्यों नहीं अंकों की सरणी के रूप में इनपुट? 54 बाइट्स

— tsh

Answer 7

पर्ल 5 , 49 + 1 ( -p) = 50 बाइट्स

s/^...|.$//g;$\=(eval s/./"-$&0+".$i++*$&/ger)%11

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

Answer 8

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

%s.e*ksbpP>Q3hT

यहाँ कोशिश करो!

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

%s*VsMKpP>Q3SlK11

यहाँ कोशिश करो!

व्याख्या

%s.e*hksbpP>Q3hT || Full program. Uses string for input and output.

            Q    || The input.
           > 3   || With elements at indexes smaller than 3 trimmed.
          P      || Pop (remove the last item).
         p       || Print the result without a linefeed, but also return it.
  .e             || Enumerated map. For each (index, value), assign two variables (k, b).
       sb        || b converted to an integer.
    *hk          || And multiplied by k + 1.
 s               || Summation.
%                || Modulo by:
               T || The literal 10.
              h  || Incremented by 1.

Answer 9

जाप , 16 15 बाइट्स

दूसरी रात पब से नीचे आया और इस बारे में सब भूल गया।

s3J
U+¬x_*°TÃuB

कोशिश करो

• 1 बाइट ने ETHproductions को धन्यवाद दिया

Comments

लगता है कि आप एक बाइट को बचा सकते हैं s3JऔरU+¬x_*°TÃuB

— ETHproductions

अजीब; मैंने शपथ ली थी कि मैं कोशिश करूँगा। धन्यवाद, @ETHproductions

— झबरा

रुको, नहीं, मैं भूल गया हूँ U- डी 'ओह!

— झबरा

Answer 10

हेक्सागोनी , 77 61 बाइट्स

,,,,'~'11=\.A&.=\./';"-'"{4.8}}\'.A.>.,<\'+'%!@}/=+'+{./&{{&/

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

---

रंग:

---

यहाँ एक बड़ा संस्करण है। कुछ पथ क्रॉसिंग हैं, लेकिन क्योंकि वे सभी कोशिकाएं .(हेक्सागोनी में नो-ऑप) हैं, आपको इसके बारे में चिंता करने की आवश्यकता नहीं है:

(मैंने पुराने दर्पणों को रखने की भी कोशिश की, लेकिन कभी-कभी मुझे कुछ बदलने की ज़रूरत होती है)

निष्पादित रैखिक कमांड है:

,,,,'48}}
,
while memory > 0:
    ';"-'"{+'+{=A&=''A
    if memory < 0:
        undefined behavior
    &{{&}
    ,
'"''+~'11='%!@

---

स्पष्टीकरण: एक काउंटर रखने और प्रत्येक अंक पर गुणा करने के बजाय, यह कार्यक्रम:

• एक "आंशिक योग" चर और "कुल योग" चर ( pऔर t) रखें
• प्रत्येक अंक के लिए पढ़ें: इसे आंशिक योग में जोड़ें, और आंशिक योग को कुल योग में जोड़ें।
• प्रिंट करें (-p-t)%11, जहां %हमेशा सकारात्मक परिणाम मिलते हैं।

Answer 11

के (ओके) , 29 25 24 23 बाइट्स

समाधान:

x,$11!7+/(1+!9)*x:-1_3_

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

उदाहरण:

x,$11!7+/(1+!9)*x:-1_3_"9780000000002"
"0000000000"
x,$11!7+/(1+!9)*x:-1_3_"9780345391803"
"0345391802"
x,$11!7+/(1+!9)*x:-1_3_"9781292101767"
"1292101768"
x,$11!7+/(1+!9)*x:-1_3_"9780452284234"
"0452284236"

स्पष्टीकरण:

मूल्यांकन दाएँ-से-बाएँ किया जाता है।

अन्य समाधानों से ली गई दो तरकीबें:

• 10 9 8 के बजाय 1 2 3 से गुणा करें ...
• ASCII मानों को गुणा करें और फिर शेष राशि में 7 जोड़ दें

टूट - फूट:

x,$11!7+/(1+!9)*x:-1_3_ / the solution
                     3_ / drop three items from the start
                  -1_   / drop one item from the end
                x:      / save this as variable x
               *        / multiply by
         (    )         / all this together
            !9          / til, !9 => 0 1 2 3 4 5 6 7 8
          1+            / add 1 => 1 2 3 4 5 6 7 8 9
      7+/               / sum (+) over (/), start from 7
   11!                  / mod by 11
  $                     / convert back to a string
x,                      / join with x

टिप्पणियाँ:

• मार्टिन एंडर्स के " बस गुणांक को उल्टा " जादू करने के लिए -4 बाइट्स धन्यवाद ।
• पूर्णांक के लिए कन्वर्ट करने की आवश्यकता को हटाने के लिए टॉम बढ़ई को -1 बाइट धन्यवाद ( 7योग जोड़कर )
• -1 बाइट 7 पर संचायक शुरू करते हैं

Answer 12

सी (जीसीसी), 96 95 87 86 85 बाइट्स

(सीलिंगकैट के लिए धन्यवाद)

*f(s,r,c,d)char*s,*r;{for(d=13;--d;s+=*++s<48)r=d>8?c=3,s:r,c-=~d**s;*s=58-c%11;s=r;}

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

के रूप में बुलाया जा सकता है f(s), जहां sएक सूचक चरित्र सरणी के पहले तत्व के लिए एक संकेतक है। इनपुट सरणी को संशोधित करता है, इनपुट सरणी में एक सूचक लौटाता है।

Answer 13

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

lambda n:n[3:12]+`-sum(i*int(n[13-i])for i in range(2,11))%11`

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

इनपुट के रूप में एक स्ट्रिंग लेता है; और एक स्ट्रिंग आउटपुट करता है।

Answer 14

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

ṫ4ṖµV€×JS%11;@

परीक्षण सूट!

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

Ṛḣ⁵µVD×JḊSN%11;ḊṚ

इसे ऑनलाइन आज़माएं! या टेस्ट सूट!

एक स्ट्रिंग के रूप में इनपुट और आउटपुट लेता है।

Answer 15

ईसीएमएस्क्रिप्ट 6 , 86 67 बाइट्स

a=>(c=a.substr(3,9))+([...c].map(v=>g+=--i*v,e=i=g=11)?(e-g%e)%e:0)

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

---

Arnauld की टिप्पणी के लिए धन्यवाद , से स्विच किया reduceगया mapऔर returnकीवर्ड से छुटकारा पा लिया गया ।

Comments

PPCG में आपका स्वागत है! उत्तर केवल पूर्ण कार्यक्रम या कॉल करने योग्य कार्य होने चाहिए (हालांकि वे अनाम कार्य हो सकते हैं), न कि केवल स्निपेट। मेरा मानना ​​है कि जावास्क्रिप्ट में सबसे छोटा विकल्प आमतौर पर एक अनाम लैम्ब्डा है।

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

@MartinEnder धन्यवाद, मैंने अपना उत्तर संपादित किया है

— कोस

बोर्ड पर आपका स्वागत है! कुछ सुझाव: परिवर्तनशील प्रारंभ आमतौर पर की अतिरिक्त पैरामीटर के रूप में रखा जा सकता है map(), reduce()आदि कुछ अतिरिक्त नए सिरे से लिखना के साथ, यह अक्सर से छुटकारा पाने के संभव है {}और return। इसके अलावा, इस विशेष मामले में,map() शायद से कम है reduce()। ( यहाँ 65-बाइट संस्करण है।)

— अरनौल्ड

मुझे पूरा यकीन f=है कि यह आवश्यक नहीं है। इसके अलावा, आप cकुछ इस तरह से फैल सकते हैं : a=>{i=10;s=[...c=a.substr(3,9)].reduce((g,v)=>+g+(i--)*v,0)%11;return c+=s?11-s:0}(-4 बाइट्स)

— Asone Tuhid

Answer 16

रेटिना 0.8.2 , 72 51 बाइट्स

...(.*).
$1¶$1
r`.\G
$&$'
r`.\G
$*
1{11}

¶(1*)
$.1

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

...(.*).
$1¶$1

अवांछित वर्ण हटाएं और उचित अंकों की दूसरी प्रति बनाएं।

r`.\G
$&$'

प्रत्यय के साथ दूसरी प्रति में प्रत्येक अंक प्रत्यय। यह प्रत्यय के प्रत्येक अंक को उसकी स्थिति के अनुसार प्रभावी रूप से दोहराता है।

r`.\G
$*

दूसरी कॉपी में अंकों को एकरूपता में बदलें ताकि उन्हें एक साथ जोड़ा जा सके।

1{11}

मॉड्यूल 11 को कम करें (पहली प्रति में केवल 9 अंक हैं, इसलिए यह कभी भी इसे प्रभावित नहीं कर सकता है।)

¶(1*)
$.1

परिणाम को वापस दशमलव में परिवर्तित करें और फिर से नई लाइन निकालें।

Answer 17

एपीएल (डायलॉग यूनिकोड) , 26 24 बाइट्स

∊⍕¨(⊢,11|⊢+.×⍳∘≢)3↓¯1↓⍎¨

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

टैसिट उपसर्ग फ़ंक्शन। इनपुट को स्ट्रिंग के रूप में लेता है।

2 बाइट्स @ngn की बदौलत बच गए।

कैसे?

∊⍕¨(⊢,11|⊢+.×⍳∘≢)3↓¯1↓⍎¨    ⍝ Main function.
                       ⍎¨    ⍝ Execute each; turns the string into a vector of digits.
                 3↓¯1↓       ⍝ Drop (↓) the last (¯1) and the first 3 digits.
   (           ≢)            ⍝ Tally; returns the number of digits in the vector.
             ⍳∘               ⍝ Then (∘) index (⍳) from 1
            ×                ⍝ Multiply the resulting vector [1..9]
         ⊢+.                 ⍝ Dot product with sum with the original vector;
                             ⍝ This will multiply both vectors, and sum the resulting vector.
      11|                    ⍝ Mod 11
     ,                       ⍝ Concatenate
    ⊢                        ⍝ With the original vector
 ⍕¨                          ⍝ Format each; returns a vector of digits as strings.
∊                            ⍝ Flatten to get rid of the spaces.

Answer 18

क्लीन , 104 102 98 बाइट्स

import StdEnv
$s#s=s%(3,11)
#i=sum[digitToInt d*p\\d<-s&p<-[10,9..]]+10
=s++[toChar(i/11*11-i+58)]

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

Answer 19

कोटलिन , 83 बाइट्स

i.drop(3).dropLast(1).let{it+(11-(it.mapIndexed{i,c->(10-i)*(c-'0')}.sum()%11))%11}

सजा हुआ

i.drop(3).dropLast(1).let {
    it + (11 - (it.mapIndexed { i, c -> (10 - i) * (c - '0') }.sum() % 11)) % 11
}

परीक्षा

data class Test(val input: String, val output: String)

fun f(i: String) =

i.drop(3).dropLast(1).let{it+(11-(it.mapIndexed{i,c->(10-i)*(c-'0')}.sum()%11))%11}

val tests = listOf(
        Test("9780000000002", "0000000000"),
        Test("9780201882957", "0201882957"),
        Test("9781420951301", "1420951300"),
        Test("9780452284234", "0452284236"),
        Test("9781292101767", "1292101768"),
        Test("9780345391803", "0345391802")
)

fun main(args: Array<String>) {
    for (c in tests) {
        val answer = f(c.input)
        val good = answer == c.output
        println("$good ${c.input} -> ${c.output} | $answer")
    }
}

TIO

TryItOnline

Answer 20

रूबी , 69 68 64 बाइट्स

->n{v=n[3,9];c=11;v+"#{(c-v.chars.map{|i|i.to_i*c-=1}.sum)%11}"}

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

Answer 21

PHP, 64 बाइट्स

दुर्भाग्य से, PHP (-$c)%11में के रूप में ही है -($c%11); इसलिए मुझे केवल उपयोग करने के बजाय कम से कम सबसे बड़ा संभव अंतर (55 * 9 = 495 = 45 * 11) प्राप्त करना होगा -$c%11।

for($f=11;--$f>1;print$d)$c+=$f*$d=$argn[13-$f];echo(495-$c)%11;

या

for($c=45*$f=11;--$f>1;print$d)$c-=$f*$d=$argn[13-$f];echo$c%11;

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया उन्हें आज़माएं ।

Answer 22

जावा 10, 110 बाइट्स

l->{var s=l+"";int c=0,i=3;for(;i<12;)c+=(13-i)*(s.charAt(i++)-48);return(l-(long)978e10)/10*10+(11-c%11)%11;}

एक longपूर्णांक के रूप में इनपुट और आउटपुट लेता है । इसे यहाँ ऑनलाइन आज़माएँ ।

Ungolfed संस्करण:

l -> { // lambda taking a long as argument
    var s = l + ""; // convert the input to a String
    int c = 0, // the check digit
    i = 3; // variable for iterating over the digits
    for(; i < 12 ;) // go from the first digit past 978 to the one before the check digit
        c += (13 - i) * (s.charAt(i++) - 48); // calculate the check sum
    return (l - (long) 978e10) // remove the leading 978
           /10 *10 // remove the original check digit
           + (11 - c % 11) % 11; // add the new check digit
}