33

एक EAN-8 बारकोड की जानकारी और एक 8 वीं चेकसम अंकों के 7 अंक हैं।

चेकसम की गणना अंकों को 3 और 1 से वैकल्पिक रूप से गुणा करके, परिणामों को जोड़कर, और 10 के अगले कई से घटाकर की जाती है।

उदाहरण के लिए, अंक दिए गए 2103498:

Digit:        2   1   0   3   4   9   8
Multiplier:   3   1   3   1   3   1   3
Result:       6   1   0   3  12   9  24

इन परिणामित अंकों का योग 55 है , इसलिए चेकसम अंक 60 - 55 = 5 है

चुनौती

आपका कार्य 8 अंकों की बारकोड दिया गया है, यह सत्यापित करें कि क्या यह वैध है - यदि चेकसम मान्य है, और अन्यथा गलत है, तो एक सत्य मान लौटाएं।

आप निम्न में से किसी भी रूप में इनपुट ले सकते हैं:
- एक स्ट्रिंग, लंबाई में 8 वर्ण, बारकोड अंकों का प्रतिनिधित्व करते हैं
- 8 पूर्णांक की एक सूची, बारकोड के अंक
- एक गैर नकारात्मक पूर्णांक (आप या तो प्रमुख शून्य जहां कोई भी दिया जाता है, यह मान सकते हैं यानी 1= 00000001, यह देखते हुए शून्य के साथ या अनुरोध इनपुट)
ईएएन -8 चेकसम (यानी, पहले 7 अंक लेने और आखिरी की गणना करने वाले) पर प्रतिबंध लगाने वाले बिल्ड पर प्रतिबंध लगा दिया गया है।
यह कोड-गोल्फ है , इसलिए सबसे छोटा कार्यक्रम (बाइट्स में) जीतता है!

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

20378240 -> True
33765129 -> True
77234575 -> True
00000000 -> True

21034984 -> False
69165430 -> False
11965421 -> False
12345678 -> False

— FlipTack
स्रोत

क्रेडिट कार्ड नंबर की पुष्टि के लिए Luhn एल्गोरिथम से संबंधित , संभवतः एक डुबकी।

— xnor

1

यह प्रश्न वास्तव में एक बार कोड (जो ब्लैक-व्हाइट धारीदार चीज़ है) के बारे में नहीं है, लेकिन बारकोड द्वारा एन्कोड किए गए नंबर के बारे में है। बार कोड के बिना संख्या मौजूद हो सकती है, और बार कोड ईएएन के अलावा अन्य चीजों को भी एनकोड कर सकता है। शायद सिर्फ " क्या मेरा EAN-8 वैध है " एक बेहतर शीर्षक है?

— पाओलो एबरमन

2

@ Pa @loEbermann के पास इसके लिए एक ही अंगूठी नहीं है ...

— FlipTack

7

बारकोड के बारे में पढ़ते समय, मैं कुछ इमेज रीडिंग (या कम से कम एक बिट-स्ट्रिंग) की अपेक्षा करता हूं, चेकसम को सत्यापित नहीं करता।

— पाओलो एबरमन

मजबूत रूप से संबंधित , चूंकि आईएसबीएन -13 एक ईएएन है।

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

5

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

s2Sḅ3⁵ḍ

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

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

s2Sḅ3⁵ḍ  Main link. Argument: [a,b,c,d,e,f,g,h] (digit array)

s2       Split into chunks of length 2, yielding [[a,b], [c,d], [e,f], [g,h]].
  S      Take the sum of the pairs, yielding [a+c+e+g, b+d+f+h].
   ḅ3    Convert from ternary to integer, yielding 3(a+c+e+g) + (b+d+f+h).
     ⁵ḍ  Test if the result is divisible by 10.

— डेनिस
स्रोत

13

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

2 बाइट्स @ETHProductions और 1 बाइट थैंक्स @Craig Ayre के लिए धन्यवाद।

s=>s.map(e=>t+=e*(i^=2),t=i=1)|t%10==1

अंकों की सूची के रूप में इनपुट लेता है।

चेकसम सहित सभी अंकों का योग निर्धारित करता है।

यदि योग 10 का गुणक है, तो यह एक वैध बारकोड है।

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

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

let f=

s=>s.map(e=>t+=e*(i^=2),t=i=1)|t%10==1

console.log(f([2,0,3,7,8,2,4,0]));
console.log(f([3,3,7,6,5,1,2,9]));
console.log(f([7,7,2,3,4,5,7,5]));
console.log(f([0,0,0,0,0,0,0,0]));

console.log(f([2,1,0,3,4,9,8,4]));
console.log(f([6,9,1,6,5,4,3,0]));
console.log(f([1,1,9,6,5,4,2,1]));
console.log(f([1,2,3,4,5,6,7,8]));

Expand snippet

— रिक हिचकॉक
स्रोत

मैं तुम्हें द्वारा 3 बाइट्स बचा सकता है कहने के लिए जा रहा था के बाद प्रत्यावर्तन के लिए पूर्व प्रत्यावर्तन से स्विच के साथ g=([n,...s],i=3,t=0)=>n?g(s,4-i,t+n*i):t%10<1है, लेकिन आप एक बेहतर तरीका मिल गया है सकते हैं ...

— ETHproductions

धन्यवाद, @ETHproductions, मैं बदल गया हूँ map, जो मुझे लगता है कि बेहतर काम करता है क्योंकि इनपुट एक स्ट्रिंग के बजाय अंकों की एक सूची हो सकती है।

— रिक हिचकॉक

शायद एक और बाइट के साथ बचा s=>s.map(e=>t+=e*(i=4-i),t=i=1)&&t%10==1?

— 16:15 बजे ETHproductions

हां, शानदार, धन्यवाद

— रिक हिचकॉक

महान समाधान! आप की जगह किया जा सका &&साथ |truthy के बाद से उत्पादन 1/0 करने के लिए / falsy अनुमति दी है?

— क्रेग आयरे

10

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

mypetlion ने 19 बाइट्स बचाए

lambda x:sum(x[::2]*2+x)%10<1

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

— हलवार्ड वुल्म
स्रोत

lambda x:sum(x[::2]*3+x[1::2])%10<135 बाइट्स के लिए।

— म्युटेलियन

2

lambda x:sum(x[::2]*2+x)%10<129 बाइट्स के लिए।

— mypetlion

8

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

m2Ḥ+µS⁵ḍ

परीक्षण सूट की कोशिश करो।

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

JḂḤ‘×µS⁵ḍ

इसे ऑनलाइन आज़माएं या परीक्षण सूट आज़माएं।

यह कैसे काम करता है

एम 2 + ⁵ḍS⁵ḍ ~ पूर्ण कार्यक्रम।

एम 2 ~ मॉड्यूलर 2. इनपुट के हर दूसरे तत्व को वापस करें।
  Ḥ ~ प्रत्येक डबल।
   + mon ~ इनपुट को बढ़ाएं और एक नई मौद्रिक श्रृंखला शुरू करें।
     S ~ सम।
      ⁵ḍ ~ 10 से विभाज्य है?

J '× ⁵ḍS⁵ḍ ~ पूर्ण कार्यक्रम (मोनैडिक)।

J ~ 1-अनुक्रमित लंबाई सीमा।
 Ḃ ~ बिट; 2 से ऊपर की सीमा में प्रत्येक संख्या को मोडुलो।
  Ḥ ~ प्रत्येक डबल।
   '~ वेतन वृद्धि प्रत्येक।
    × ~ इनपुट के साथ जोड़ीदार गुणा।
     µ ~ एक नई मोनडिक श्रृंखला शुरू करता है।
      S ~ सम।
       ⁵ḍ ~ 10 से योग विभक्त है?

बारकोड के पहले 7 अंकों और चेकसम अंक के लिए परिणाम को मान्य होने के लिए इसे 10 से अधिक में जोड़ना होगा । इस प्रकार, चेकसम मान्य है यदि पूरी सूची पर लागू एल्गोरिथ्म 10 से विभाज्य है ।

— मिस्टर एक्सकोडर
स्रोत

अभी भी 9 बाइट्स लेकिन सुसंगत मूल्यों के साथ:JḂḤ‘×µS⁵ḍ

— हाइपरएनुट्रिनो

@ हायपरनेट्रिनो धन्यवाद, मुझे पता था कि इसके लिए एक परमाणु था!

— श्री एक्सकोडर

इसके अलावा 9 बाइट्स:: JḂaḤ+µS⁵ḍपी

— हाइपरएन्यूट्रीनो

@ हाइपर न्यूट्रिनो बहुत सारे विकल्प हैं: पी

— श्री एक्सकोडर

1

8 बाइट्स या 8 अक्षर? m2Ḥ+µS⁵ḍUTF-8 में 15 बाइट्स हैं, जब तक कि मैंने इसकी गलत गणना नहीं की है।

— ta.speot.is

7

MATL , 10 बाइट्स

गलती को इंगित करने के लिए @Zgarb को धन्यवाद , अब सही किया गया।

IlhY"s10\~

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

व्याख्या

Ilh     % Push [1 3]
Y"      % Implicit input. Run-length decoding. For each entry in the
        % first input, this produces as many copies as indicated by
        % the corresponding entry of the second input. Entries of
        % the second input are reused cyclically
s       % Sum of array
10\     % Modulo 10
~       % Logical negate. Implicit display

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

7

बेफ़ुंज -98 (PyFunge) , 16 14 बाइट्स

सेकेंड के jबजाय दूसरे भाग को छोड़ कर 2 बाइट्स बचाए ;, साथ ही दूसरे भाग से छुटकारा पाने के लिए पहले भाग में स्वैपिंग ~और +ए +।

~3*+~+6jq!%a+2

इनपुट 8 अंकों में है (यदि लागू हो तो 0 के साथ) और कुछ नहीं।

एक्ज़िट कोड के माध्यम से आउटपुट (TIO पर डिबग ड्रॉपडाउन खोलें), जहां 1 सत्य है और 0 गलत है।

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

व्याख्या

यह प्रोग्राम कई तरह के ट्रिक्स का उपयोग करता है।

सबसे पहले, यह अपने ASCII मूल्यों के माध्यम से एक-एक करके अंकों को लेता है। आम तौर पर, हमें इनपुट से पढ़ते समय प्रत्येक मूल्य से 48 घटाना होगा। हालांकि, अगर हम इसे संशोधित नहीं करते हैं, तो हम 16 (3 + 1 + 3 + 1 + 3 + 1 + 3 + 1) के साथ बचे हैं, हमारी राशि में 48 की अतिरिक्त प्रतियां, जिसका अर्थ है कि हमारा कुल 768 से अधिक होने जा रहा है यह "क्या" होना चाहिए। चूँकि हम केवल योग 10 से संबंधित हैं, हम बाद में योग में केवल 2 जोड़ सकते हैं। इस प्रकार, हम 6 बाइट्स या तो बचत करके कच्चे ASCII मूल्यों में ले सकते हैं।

दूसरे, यह कोड केवल यह जांचता है कि क्या प्रत्येक अन्य वर्ण EOF है, क्योंकि इनपुट केवल 8 वर्ण लंबा होने की गारंटी है।

तीसरी बात, #पंक्ति के अंत में पहला वर्ण नहीं छोड़ता है, लेकिन ;दूसरी दिशा से आने पर छोड़ देगा । इसके #;बजाय सामने की ओर लगाने से बेहतर है ।

क्योंकि हमारे कार्यक्रम का दूसरा भाग केवल एक बार चलाया जाता है, इसलिए हमें इसे स्थापित करने की आवश्यकता नहीं है ताकि यह पीछे की ओर दौड़ते समय पहले आधे हिस्से को छोड़ दे। यह हमें दूसरी छमाही में कूदने के लिए जंप कमांड का उपयोग करने की अनुमति देता है, क्योंकि हम इसे पीछे की ओर जाने से पहले बाहर निकलते हैं।

क्रमशः

नोट: "विषम" और "सम" अक्षर 0-अनुक्रमित प्रणाली पर आधारित हैं। पहला वर्ण इंडेक्स 0 के साथ एक समरूप है।

~3*+~+      Main loop - sum the digits (with multiplication)
~           If we've reached EOF, reverse; otherwise take char input. This will always
                be evenly indexed values, as we take in 2 characters every loop.
 3*+        Multiply the even character by 3 and add it to the sum.
    ~       Then, take an odd digit - we don't have to worry about EOF because
                the input is always 8 characters.
     +      And add it to the sum.
      6j    Jump over the second part - We only want to run it going backwards.

        q!%a+2    The aftermath (get it? after-MATH?)
            +2    Add 2 to the sum to make up for the offset due to reading ASCII
          %a      Mods the result by 10 - only 0 if the bar code is valid
         !        Logical not the result, turning 0s into 1s and anything else into 0s
        q         Prints the top via exit code and exits

— MildlyMilquetoast
स्रोत

6

सी, 78 77 बाइट्स

i,s,c,d=10;f(b){for(i=s=0,c=b%d;b/=d;)s+=b%d*(3-i++%2*2);return(d-s%d)%d==c;}

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

सी (जीसीसी), 72 बाइट्स

i,s,c,d=10;f(b){for(i=s=0,c=b%d;b/=d;)s+=b%d*(i++%2?:3);b=(d-s%d)%d==c;}

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

— Steadybox
स्रोत

6

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 26 21 बाइट्स

10∣(2-9^Range@8).#&

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

इनपुट को 8 अंकों की सूची के रूप में लेता है।

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

2-9^Range@8अनुकूल सापेक्ष 10 करने के लिए है 2-(-1)^Range@8, जो {3,1,3,1,3,1,3,1}। हम इस सूची के डॉट उत्पाद को इनपुट के साथ लेते हैं, और जांचें कि क्या परिणाम 10 से विभाज्य है।

वोल्फ्राम भाषा (गणितज्ञ) , 33 बाइट्स और गैर-प्रतिस्पर्धात्मक

Check[#~BarcodeImage~"EAN8";1,0]&

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

एक स्ट्रिंग के रूप में इनपुट लेता है। 1वैध बारकोड और 0अमान्य लोगों के लिए रिटर्न ।

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

सबसे अच्छी बात मैं एक अंतर्निहित (जिस तरह से गणितज्ञ उन सभी के बारे में है) के रास्ते में पा सकता था।

अंदर का बिट, #~BarcodeImage~"EAN8";1EAN8 बारकोड की एक छवि बनाता है, फिर इसे पूरी तरह से अनदेखा करता है और 1. का मूल्यांकन करता है। हालांकि, अगर बारकोड अमान्य है, तो BarcodeImageएक चेतावनी उत्पन्न करता है, जो Checkउस स्थिति में 0 पर वापस लौटता है।

— मिशा लावरोव
स्रोत

3

क्या आप हाथ से गणना कर रहे हैं क्योंकि यह छोटा है, या क्योंकि वुल्फरम के पास अभी तक अपने मानक पुस्तकालय में कहीं भी ValidateEAN8BarCode () फ़ंक्शन नहीं है?

— मार्क

1

@ मर्क गणितज्ञ सीधे बारकोड को मान्य नहीं कर सकता है , लेकिन मैंने अभी पाया BarcodeImage, जो बारकोड की छवि उत्पन्न करता है, और प्रक्रिया में बारकोड को मान्य करता है। तो Check[#~BarcodeImage~"EAN8";0,1]<1&काम करेगा (लेकिन यह लंबा है)।

— मिशा लावरोव

5

जावा 8, 58 56 55 बाइट्स

a->{int r=0,m=1;for(int i:a)r+=(m^=2)*i;return r%10<1;}

-2 बाइट्स अप्रत्यक्ष रूप से @RickHitchcock की बदौलत , उसके जावास्क्रिप्ट उत्तर में देखने के (m=4-m)*iबजाय उपयोग करके । -1 बाइट अप्रत्यक्ष रूप से @ETHProductions (और @RickHitchcock ) के लिए धन्यवाद , इसके बजाय का उपयोग करके ।m++%2*2*i+i
(m^=2)*i(m=4-m)*i

स्पष्टीकरण:

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

a->{              // Method with integer-array parameter and boolean return-type
  int r=0,        //  Result-sum
      m=1;        //  Multiplier
  for(int i:a)    //  Loop over the input-array
    r+=           //   Add to the result-sum:
       (m^=2)     //    Either 3 or 1,
       *i;        //    multiplied by the digit
                  //  End of loop (implicit / single-line body)
  return r%10<1;  //  Return if the trailing digit is a 0
}                 // End of method

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

1

आप एक अन्य बाइट को एक ट्रिक के साथ बचा सकते हैं @ETHProductions ने मुझे दिखाया: परिवर्तन m=4-mकरना m^=2।

— रिक हिचकॉक

@RickHitchcock आह, बिल्कुल .. मैं ^=1जवाब में बहुत बार उपयोग करता हूं जब मैं बीच में बदलना चाहता हूं 0और 1। ^=2इस मामले में 1और के बीच फेरबदल करने के लिए काम करता है 3। अच्छी चाल, और टिप्पणी का उल्लेख करने के लिए धन्यवाद। :)

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

4

05AB1E , 14 बाइट्स

θ¹¨3X‚7∍*O(T%Q

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

अग्रणी 0s की आवश्यकता है , अंकों की सूची लेता है।

— आउटगोल्फर को एरिक करें
स्रोत

पर विफल होने लगता है 3100004(सत्य होना चाहिए)।

— जरगब

@Zgarb तुम 0वहाँ याद आ रहे हैं ।

— निकोलग्राफ

ओह, यह एक स्ट्रिंग लेता है? ठीक है, तो मेरी बुर।

— जरगब

@Zgarb खैर, आप उद्धरण को छोड़ सकते हैं, लेकिन हां, आपको अग्रणी की आवश्यकता है 0। यह उत्तर वास्तव में स्ट्रिंग पर संख्या कार्यों का उपयोग करता है, 05AB1E की विशेषताओं में से एक।

— आउटगॉल्फ

@ Mr.Xcoder प्रश्न उस पर बहुत स्पष्ट नहीं है, मैं एक और कोड जोड़ूंगा जो नीचे के लिए संभालता है।

— आउटगॉल्फ

4

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

!es+*2%2

सभी परीक्षण मामलों की पुष्टि करें!

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

यदि हम मान सकते हैं कि इनपुट में हमेशा 8 अंक हैं:

!es.e*bhy%hk2

सभी परीक्षण मामलों की पुष्टि करें!

यह कैसे काम करता है?

! es + * 2% 2 ~ पूर्ण कार्यक्रम।

      % 2 ~ इनपुट [:: 2]। इनपुट का हर दूसरा तत्व।
    * 2 ~ डबल (सूची दो बार दोहराएं)।
   + ~ इनपुट जोड़ें।
  s ~ सम।
 ई ~ अंतिम अंक।
! ~ तार्किक नहीं।

? es.e * sbhy% hk2 ~ पूर्ण कार्यक्रम।

               ~ इनपुट को स्ट्रिंग में कनवर्ट करें।
   .e ~ Enumerated मैप, b में करंट वैल्यू और k में इंडेक्स को स्टोर करता है।
          % hk2 ~ सूचकांक की उलटी समता। (k + 1)% 2
        हाई ~ डबल, वेतन वृद्धि। यह 1 और यहां तक कि 3 से विषम पूर्णांक को मैप करता है।
      b ~ वर्तमान अंक।
     * * गुणा करें।
  s ~ सम।
 ई ~ अंतिम अंक।
! ~ तार्किक उपेक्षा

यदि एल्गोरिथम लागू होने के बाद पहले 7 अंक का योग 10 से घटाया जाता है और फिर अंतिम अंक की तुलना में, यह जाँचने के बराबर है कि क्या एल्गोरिथम लागू होने के बाद सभी अंकों का योग 10 से अधिक है ।

— मिस्टर एक्सकोडर
स्रोत

पर विफल होने लगता है 3100004(सत्य होना चाहिए)।

— जरगब

@Zbb रुको हमें करना चाहिए 3*3+1*1+0*3+...या 0*3+3*1+1*0..? मुझे लगा कि हम पूर्व

— श्री एक्सकोडर

नए अनुमान में, यह सुनिश्चित करने के लिए प्रमुख अंक जोड़े जाते हैं कि वास्तव में 8 हैं (यदि मैं सही ढंग से समझता हूं)।

— जरगब

@Zgarb ठीक है, ठीक किया गया।

— श्री Xcoder

4

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

a=3:1:a
f x=mod(sum$zipWith(*)a x)10<1

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

8 पूर्णांकों की सूची के रूप में इनपुट लेता है। अनंत सूचियों का उपयोग करने का एक व्यावहारिक उदाहरण।

संपादित करें: सहेजे गए 2 बाइट्स गोल्फवॉल्फ का धन्यवाद

— butterdogs
स्रोत

2

cycle 2 बाइट्स सहेजने के बजाय पुनरावर्ती परिभाषा का उपयोग करना ।

— क्रिस्टियन लुपस्कू

4

रेटिना , 23 22 बाइट्स

मार्टिन एंडर को -1 बाइट धन्यवाद !

(.).
$1$1$&
.
$*
M`
1$

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

व्याख्या

उदाहरण इनपुट: 20378240

(.).
$1$1$&

प्रत्येक जोड़े को पहले दो बार दोहराए गए अंकों के साथ जोड़े और उसके बाद दो अंकों को बदलें। हमें मिला2220333788824440

.
$*

प्रत्येक अंक को एकात्मक में बदलें। कोष्ठक के साथ स्पष्टता के लिए जोड़ा, हम प्राप्त करते हैं(11)(11)(11)()(111)(111)...

M`

खाली स्ट्रिंग के मैचों की संख्या की गणना करें, जो स्ट्रिंग में लोगों की संख्या से एक अधिक है। (अंतिम दो चरणों के साथ हमने मूल रूप से प्रत्येक अंक +1 का योग लिया है) परिणाम:60

1$

1स्ट्रिंग के अंत में मिलान करें । हमने 3 और 1 के अंकों को बारी-बारी से गुणा किया है और उन्हें सारांशित किया है, एक वैध बारकोड के लिए यह 10 से विभाज्य होना चाहिए (अंतिम अंक 0); लेकिन हमने अंतिम चरण में 1 भी जोड़ा, इसलिए हम चाहते हैं कि अंतिम अंक 1. अंतिम परिणाम हो 1:।

— सिंह
स्रोत

2

मुझे लगता है कि आप .मैच के चरण पर छोड़ सकते हैं और 1$अंत में मैच कर सकते हैं ।

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

@MartinEnder बहुत अच्छा, मैं ऐसा करूँगा, धन्यवाद!

— लियो

3

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

param($a)(10-(("$a"[0..6]|%{+"$_"*(3,1)[$i++%2]})-join'+'|iex)%10)%10-eq+"$("$a"[7])"

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

एल्गोरिथ्म को परिभाषित के रूप में लागू करता है। इनपुट लेता है $a, प्रत्येक अंक को खींचता है "$a"[0..6]और उनके साथ छोरों के माध्यम से |%{...}। प्रत्येक पुनरावृत्ति, हम अंक लेते हैं, इसे एक स्ट्रिंग के रूप में डालते हैं और "$_"फिर इसे या +तो गुणा करने से पहले एक इंट के रूप में डालते हैं 3या 1( $iमॉडुलो को बढ़ाकर चुना जाता है 2)।

उन परिणामों को सभी को एक साथ इकट्ठा किया जाता है और सारांशित किया जाता है -join'+'|iex। हम उस परिणाम मॉड को लेते हैं 10, उससे घटाते हैं 10, और फिर से परिणाम मॉड लेते हैं 10(यह दूसरा मॉड 00000000परीक्षण के मामले के लिए आवश्यक है )। फिर हम जाँचते हैं कि क्या यह -eqअंतिम अंक के लिए ual है। उस बूलियन परिणाम को पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है।

— AdmBorkBork
स्रोत

पर विफल होने लगता है 3100004(सत्य होना चाहिए)।

— जर्ब

@Zgarb मेरे लिए काम करता है? इसे ऑनलाइन आज़माएं!

— AdmBorkBork

आह ठीक है, मैं इसे उद्धरण के बिना परीक्षण किया।

— जरगब

@Zgarb आह, हाँ। उद्धरण के बिना, PowerShell मुख्य रूप से एक पूर्णांक के रूप में डाली जाएगी, जो अग्रणी शून्य (एस) को छीन लेगी।

— AdmBorkBork

3

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

ż3,1ṁ$P€SN%⁵
Ṫ=Ç

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

अंकों की सूची के रूप में इनपुट लेता है

— HyperNeutrino
स्रोत

नाइटपिक: आपका TIO टाइमआउट। इसके अलावा, 16 बाइट्स ।

— निकोलगर्फ़

@EriktheOutgolfer इंतजार करें कि कैसे। यह काम करता है जब मैं Dपाद में डाल देता हूं । और याय धन्यवाद! : डी

— हाइपरनेट्रिनो

@EriktheOutgolfer क्या मैं कुछ गलत कर रहा हूं? आपका 16-बटर अमान्य प्रतीत होता है?

— हाइपरन्यूट्रिनो

हो सकता है, यह थोड़े अलग तरीके से काम करता हो, लेकिन आपका यह थोड़ा अमान्य भी लगता है ... विशेष रूप से मुझे लगता है कि अंतिम पंक्ति होनी चाहिए DµṪ=Ç।

— निकोलगर्फ़

1

पर विफल होने लगता है 3100004(सत्य होना चाहिए)।

— जरगब

3

APL (Dyalog) , 14 बाइट्स

स्ट्रीटस्टर के समाधान के साथ बराबर ।

पूर्ण कार्यक्रम निकाय। STDIN से संख्याओं की सूची के लिए संकेत।

0=10|+/⎕×8⍴3 1

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

है…

0= के बराबर शून्य

10| के मॉड -10

+/ की राशि

⎕× इनपुट समय

8⍴3 1 आठ तत्वों को चक्रीय रूप से लिया गया [3,1]

?

— एडम
स्रोत

1

आपका मतलब है कि एपीएल प्राचीन सुमेरियन या रैखिक बी जैसे कुछ से एक चरित्र में नहीं कर सकता है?

— मार्क

ट्रेन: 0 = 10 | - / + 2 × + /

— ngn

3

05AB1E , 9 बाइट्स

3X‚7∍*OTÖ

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

3X‚7∍*OTÖ    # Argument a
3X‚          # Push [3, 1]
   7∍        # Extend to length 7
     *       # Multiply elements with elements at same index in a
      O      # Total sum
       TÖ    # Divisible by 10

— kalsowerus
स्रोत

अच्छा! पहली बात मैंने सोचा था कि जब मैंने इसे देखा, तो "लंबाई का विस्तार" किया, जिसने अभी तक इसका उपयोग नहीं किया है।

— मैजिक ऑक्टोपस Urn

31×S*OTÖ8 बाइट्स के लिए। ×बस 31 nबार धक्का देता है । जब आप गुणा करते हैं, तो यह स्वचालित रूप से अतिरिक्त 31 को गिरा देता है।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn जो 6 वें 69165430 -> 1

— टेस्टकेस

3

जे, 17 बाइट्स

-10 बाइट्स कोल के लिए धन्यवाद

0=10|1#.(8$3 1)*]

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

यह मूल समाधान के जिप / गुणा कॉम्बो से बचने के लिए समान आकार की सूचियों के गुणन का उपयोग करता है, साथ ही 1#.साथ उत्पादों को जोड़ने के लिए "आधार 1 चाल" भी । उच्च स्तरीय दृष्टिकोण मूल स्पष्टीकरण के समान है।

मूल, 27 बाइट्स

0=10|{:+[:+/[:*/(7$3 1),:}:

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

व्याख्या की

0 =                                        is 0 equal to... 
    10 |                                   the remainder when 10 divides...
         {: +                              the last input item plus...
              [: +/                        the sum of...
                    [: */                  the pairwise product of...
                          7$(3 1) ,:       3 1 3 1 3 1 3 zipped with...
                                     }:    all but the last item of the input

— जोनाह
स्रोत

0=10|1#.(8$3 1)*]17 बाइट्स के लिए काम करना चाहिए (एक ही एल्गोरिथ्म भी करता है)। मुझे पूरा यकीन है कि बीटा में आप संज्ञा के साथ दाईं ओर एक हुक समाप्त कर सकते हैं, इसलिए 0=10|1#.]*8$3 115 के लिए काम कर सकते हैं (मैं tio पर जांच करूंगा लेकिन यह नीचे लगता है?)

— कोल

@, मुझे यह सुधार बहुत पसंद है। मैंने 1#.2 या 3 बार चाल के बारे में सीखा है और मुझे भूल गया है ... मुझे याद दिलाने के लिए धन्यवाद। ओह btw 15 बाइट संस्करण TIO में काम नहीं किया।

— योना

3

सी (जीसीसी), 84 82 72 61 54 बाइट्स

c;i;f(x){for(i=c=0;x;x/=10)c+=(1+2*i++%4)*x;c=c%10<1;}

नील से -21 बाइट्स

-7 ब्यूह फाउइउल से बाइट्स

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

Steadybox के उत्तर को स्वतंत्र रूप से विकसित किया गया

'f' एक ऐसा फंक्शन है जो बारकोड को एक के रूप में लेता है int, और 1ट्रू के लिए और 0फाल्स के लिए रिटर्न करता है ।

fके पिछले अंक संग्रहीत करता है xमें s( s=x%10),
फिर c( for(i=c=0;x;x/=10)c+=(1+2*i++%4)*x;) में योग की गणना करता है
- cराशि है, iएक काउंटर है
- पहले अंक सहित प्रत्येक अंक के लिए, चेकसम और इंक्रीमेंट ( में ) के 1+2*i%4लिए अंक ( x%10) जोड़ेंii++3-2*i++%4
  - 1+2*i%41 है जब iसम है और 0 iविषम है
फिर यह बताता है कि क्या राशि दस का एक गुणक है, और चूंकि हमने अंतिम अंक (1 से गुणा किया) जोड़ा है, तो यह राशि दस से अधिक होगी यदि बारकोड वैध है। (का उपयोग करता है GCC- निर्भर करने के लिए अपरिभाषित व्यवहार निर्भर करता है return)।

— pizzapants184
स्रोत

मुझे लगता (x%10)है xकि आप c%10वैसे भी हो सकते हैं जैसे आप बाद में ले रहे हैं । इसके अलावा मुझे लगता है कि आप उपयोग कर सकते हैं i<8और फिर परीक्षण कर सकते हैं कि क्या c%10अंत में शून्य है।

— नील

@ नील धन्यवाद! कि -10 बाइट्स मिलीं।

— pizzapants184

वास्तव में मुझे लगता sहै कि अनावश्यक है:c;i;f(x){for(i=c=0;i<8;x/=10)c+=(1+2*i++%4)*x;return c%10<1;}

— नील

tio लिंक 61 बाइट्स है, लेकिन जवाब में यह 72 है, यह भी नहीं पता कि क्यों x=c%10<1या c=c%10<1इसके बजाय return c%10<1अभी भी काम करता है

— Nahuel Fouilleul

यह भी i<8द्वारा प्रतिस्थापित किया जा सकता हैx

— नहुएल फौलीउल

3

सी, 63 बाइट्स

i;s=0;c(int*v){for(i=0;i<8;i++){s+=v[i]*3+v[++i];}return s%10;}

0माना जाता है कि trueऔर किसी भी अन्य मूल्य है false।

बेहतर वापसी मूल्य के लिए +3 बाइट्स

i;s=0;c(int*v){for(i=0;i<8;i++){s+=v[i]*3+v[++i];}return s%10==0;}

जोड़े ==0को returnबयान।

Ungolfed

int check(int* values)
{
    int result = 0;
    for (int index = 0; index < 8; index++)
    {
        result += v[i] * 3 + v[++i]; // adds this digit times 3 plus the next digit times 1 to the result
    }
    return result % 10 == 0; // returns true if the result is a multiple of 10
}

यह EAN चेकसमों की वैकल्पिक परिभाषा का उपयोग करता है जहां चेक अंक को चुना जाता है जैसे कि चेक अंक सहित पूरे बारकोड का चेकसम 10. 10 का गुणक है। गणितीय रूप से यह समान है लेकिन यह लिखने के लिए बहुत सरल है।

Steadybox, 63 बाइट्स द्वारा सुझाए गए लूप के अंदर प्रारंभिक चर

i;s;c(int*v){for(i=s=0;i<8;i++){s+=v[i]*3+v[++i];}return s%10;}

Steadybox, 61 बाइट्स द्वारा सुझाए अनुसार घुंघराले कोष्ठक को हटा दें

i;s;c(int*v){for(i=s=0;i<8;i++)s+=v[i]*3+v[++i];return s%10;}

केविन क्रूज़सेन द्वारा सुझाए गए बेहतर रिटर्न मूल्य के `<1`बजाय उपयोग करना`==0`

i;s=0;c(int*v){for(i=0;i<8;i++){s+=v[i]*3+v[++i];}return s%10<1;}

जोड़े <1को returnबयान, इस बल्कि जोड़ने से केवल 2 बाइट्स कहते हैं ==0जो 3 बाइट्स कहते हैं।

— मिशैल जॉनसन
स्रोत

के बाद हटाकर आप दो बाइट्स बचा सकते हैं । इसके अलावा, फ़ंक्शन सबमिशन को पुन: प्रयोज्य करना पड़ता है , इसलिए आपको फ़ंक्शन के अंदर इनिशियलाइज़ करने की आवश्यकता होती है (बस करने के लिए और इसे बदलें )। {}forsi;s=0;i,s;i=0;i=s=0;

— स्टेडियोबॉक्स

@Steadybox मैं घुंघराले कोष्ठक कैसे निकाल सकता हूँ?

— माइकल जॉनसन

उनके अंदर केवल एक बयान है। जब बाद में कोई घुंघराले ब्रैकेट नहीं होते हैं for, तो लूप बॉडी का अगला बयान होगा। for(i=0;i<8;i++){s+=v[i]*3+v[++i];}के रूप में ही है for(i=0;i<8;i++)s+=v[i]*3+v[++i];।

— स्टेडीबॉक्स

@Steadybox ओह बेशक। यह C सिंटैक्स के उन प्रश्नों में से एक है जिसे मैं आमतौर पर भूल जाता हूं, क्योंकि सामान्य कोड लिखते समय मैं हमेशा घुंघराले ब्रैकेट को शामिल करता हूं, भले ही वे अनावश्यक हों, क्योंकि यह कोड को अधिक पठनीय बनाता है।

— जॉनसन

आपके सही / गलत उत्तर में, +3 के बजाय ==0इसे जोड़कर +2 का उपयोग करके किया जा सकता है <1। :)

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

2

जावास्क्रिप्ट (Node.js) , 47 बाइट्स

e=>eval(e.map((a,i)=>(3-i%2*2)*a).join`+`)%10<1

हालाँकि पहले से ही बहुत कम जवाब है, यह जावास्क्रिप्ट में गोल्फिंग का मेरा पहला प्रयास है, इसलिए मैं गोल्फ सिफारिशों को सुनना चाहूंगा :-)

परिक्षण

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

let f=

e=>eval(e.map((a,i)=>(3-i%2*2)*a).join`+`)%10<1

console.log(f([2,0,3,7,8,2,4,0]));
console.log(f([3,3,7,6,5,1,2,9]));
console.log(f([7,7,2,3,4,5,7,5]));
console.log(f([0,0,0,0,0,0,0,0]));

console.log(f([2,1,0,3,4,9,8,4]));
console.log(f([6,9,1,6,5,4,3,0]));
console.log(f([1,1,9,6,5,4,2,1]));
console.log(f([1,2,3,4,5,6,7,8]));

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

वैकल्पिक रूप से, आप इसे ऑनलाइन आज़मा सकते हैं !

— मिस्टर एक्सकोडर
स्रोत

2

पर्ल 5, 37 32 + 1 (-पी) बाइट्स

s/./$-+=$&*(--$|*2+1)/ge;$_=/0$/

डोम बस्ती के लिए -5 बाइट्स धन्यवाद। 37 +1 बाइट्स थी

$s+=$_*(++$i%2*2+1)for/./g;$_=!!$s%10

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

— नहुएल फौलीउल
स्रोत

1

इस के साथ एक छोटा सा नाटक किया था और सोचा था कि मैं एक उपयोगी ट्रिक साझा करूंगा: --$|बीच में टॉगल करें 1और 0इसलिए आप इसे ++$i%2एक वैकल्पिक मल के बजाय उपयोग कर सकते हैं ! इसके अलावा, यह सब मायने रखता है कि कुल ( $s) मैच /0$/, उन परिवर्तनों के साथ 33 बाइट्स प्राप्त करने में कामयाब रहे s///: इसे ऑनलाइन आज़माएं! ( -lकेवल दृश्यता के लिए)

— डोम हेस्टिंग्स

हाँ, हालांकि, मैं मिलाप करने के s/./(something with $&)/geलिए, /0$/लेकिन दोनों संयुक्त नहीं।

— नहुएल फौलीउल

2

ब्रेनफक, 228 बाइट्स

>>>>++++[<++>-]<[[>],>>++++++[<++++++++>-]<--[<->-]+[<]>-]>[->]<<<<[[<+>->+<]<[>+>+<<-]>>[<+>-]<<<<<]>>>>[>>[<<[>>+<<-]]>>]<<<++++[<---->-]+++++[<++<+++>>-]<<[<[>>[<<->>-]]>[>>]++[<+++++>-]<<-]<[[+]-<]<++++++[>++[>++++<-]<-]>>+.

शायद एक निष्पक्ष बिट में सुधार किया जा सकता है। इनपुट को एक बार में 1 अंक लिया जाता है, 1 को सही, 0 को गलत के लिए आउटपुट देता है।

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

>>>>++++[<++>-]<

स्थिति 3 पर 8 रखो।

[[>],>>++++++[<++++++++>-]<--[<->-]+[<]>-]

8 बार इनपुट लेता है, इसे हर बार एएससीआई मान से वास्तविक मूल्य +2 में बदल देता है। बाद में आसान गुणा के लिए अनुमति देने के लिए इनपुट्स को हटा दिया जाता है।

>[->]

प्रत्येक आइटम से एक घटाएँ। हमारा टेप अब कुछ ऐसा दिखता है

0 0 0 0 4 0 4 0 8 0 7 0 6 0 2 0 3 0 10 0 0
                                         ^

प्रत्येक मान के साथ 1 से अधिक होना चाहिए। ऐसा इसलिए है क्योंकि शून्य हमारी गुणा प्रक्रिया को गड़बड़ कर देगा।

अब हम गुणा करना शुरू करने के लिए तैयार हैं।

<<<<

दूसरे से अंतिम आइटम पर जाएं।

[[<+>->+<]<[>+>+<<-]>>[<+>-]<<<<<]

शून्य होने पर, आइटम को तीन से गुणा करें, फिर दो आइटम को बाईं ओर ले जाएं। अब हमने जो कुछ भी आवश्यक है उसे तीन से गुणा किया है, और हम टेप पर पहले स्थान पर हैं।

>>>>[>>[<<[>>+<<-]]>>]

पूरी सूची को जोड़ो।

<<<++++[<---->-]

हमारे पास जो मूल्य है वह वास्तविक मूल्य से 16 अधिक है। 16 घटाकर इसे ठीक करें।

+++++[<++<+++>>-]

हमें यह जांचने की आवश्यकता है कि क्या राशि 10 का गुणक है। अधिकतम योग सभी 9s के साथ है, जो 144 है। चूंकि कोई राशि 10 * 15 से अधिक नहीं होगी, इसलिए टेप पर 15 और 10 डालें, उस क्रम में और सही राशि का अधिकार।

<<[<[>>[<<->>-]]>[>>]++[<+++++>-]<<-]

जहां 15 है वहां ले जाएं। हालांकि यह गैर-शून्य है, यदि परीक्षण गैर-शून्य है। यदि यह है, तो इसमें से 10 घटाएं। अब हम या तो (खाली) योग स्थिति पर हैं, या (खाली भी) दस पद हैं। एक सही हटो। यदि हम योग स्थिति पर थे, तो अब हम गैर-शून्य 15 स्थिति पर हैं। यदि ऐसा है, तो दो बार दाईं ओर ले जाएं। अब हम दोनों मामलों में एक ही स्थिति में हैं। दस को दस स्थिति में जोड़ें, और 15 में से एक को घटाएं।

बाकी उत्पादन के लिए है:

<[[+]-<]<++++++[>++[>++++<-]<-]>>+.

योग की स्थिति में जाएं। यदि यह गैर-शून्य (नकारात्मक) है, तो बारकोड अमान्य है; -1 पर स्थिति सेट करें। अब सही एससीआई मान प्राप्त करने के लिए 49 जोड़ें: 1 यदि यह वैध है, तो यदि यह अमान्य है तो 0।

— बोलस बूसियर
स्रोत

2

जावा 8, 53 बाइट्स

golfed:

b->(3*(b[0]+b[2]+b[4]+b[6])+b[1]+b[3]+b[5]+b[7])%10<1

लैम्ब्डा में प्रत्यक्ष गणना सबसे छोटे समाधान के लिए दिखाई देती है। यह एक एकल अभिव्यक्ति में फिट बैठता है, लैम्ब्डा ओवरहेड को कम करता है और एक्स्ट्रासियस चर घोषणाओं और अर्धविराम को हटाता है।

public class IsMyBarcodeValid {

  public static void main(String[] args) {
    int[][] barcodes = new int[][] { //
        { 2, 0, 3, 7, 8, 2, 4, 0 }, //
        { 3, 3, 7, 6, 5, 1, 2, 9 }, //
        { 7, 7, 2, 3, 4, 5, 7, 5 }, //
        { 0, 0, 0, 0, 0, 0, 0, 0 }, //
        { 2, 1, 0, 3, 4, 9, 8, 4 }, //
        { 6, 9, 1, 6, 5, 4, 3, 0 }, //
        { 1, 1, 9, 6, 5, 4, 2, 1 }, //
        { 1, 2, 3, 4, 5, 6, 7, 8 } };
    for (int[] barcode : barcodes) {
      boolean result = f(b -> (3 * (b[0] + b[2] + b[4] + b[6]) + b[1] + b[3] + b[5] + b[7]) % 10 < 1, barcode);
      System.out.println(java.util.Arrays.toString(barcode) + " = " + result);
    }
  }

  private static boolean f(java.util.function.Function<int[], Boolean> f, int[] n) {
    return f.apply(n);
  }
}

आउटपुट:

[2, 0, 3, 7, 8, 2, 4, 0] = true
[3, 3, 7, 6, 5, 1, 2, 9] = true
[7, 7, 2, 3, 4, 5, 7, 5] = true
[0, 0, 0, 0, 0, 0, 0, 0] = true
[2, 1, 0, 3, 4, 9, 8, 4] = false
[6, 9, 1, 6, 5, 4, 3, 0] = false
[1, 1, 9, 6, 5, 4, 2, 1] = false
[1, 2, 3, 4, 5, 6, 7, 8] = false

2

QBasic, 54 52 बाइट्स

ऊ, बोरिंग जवाब निकला सबसे छोटा:

INPUT a,b,c,d,e,f,g,h
?(3*a+b+3*c+d+3*e+f+3*g+h)MOD 10=0

यह अंकों को अल्पविराम से अलग करता है। मेरा मूल 54-बाइट समाधान, जो एक समय में एक अंक इनपुट करता है, एक "अच्छे" दृष्टिकोण का उपयोग करता है:

m=3
FOR i=1TO 8
INPUT d
s=s+d*m
m=4-m
NEXT
?s MOD 10=0

— DLosc
स्रोत

2

सी # (.NET कोर) , 65 62 बाइट्स

b=>{int s=0,i=0,t=1;while(i<8)s+=b[i++]*(t^=2);return s%10<1;}

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

स्वीकृतियाँ

-3 बाइट्स @KevinCruijssen और विशेष या ऑपरेटर का उपयोग करके साफ चाल के लिए धन्यवाद।

DeGolfed

b=>{
    int s=0,i=0,t=1;

    while(i<8)
        s+=b[i++]*(t^=2); // exclusive-or operator alternates t between 3 and 1.

    return s%10<1;
}

सी # (.NET कोर) , 53 बाइट्स

b=>(3*(b[0]+b[2]+b[4]+b[6])+b[1]+b[3]+b[5]+b[7])%10<1

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

@ स्नोमैन के उत्तर का सीधा पोर्ट ।

— Ayb4btu
स्रोत

आपके पहले उत्तर के लिए: b=>{int s=0,i=0,t=1;while(i<8)s+=b[i++]*(t^=2);return s%10<1;}( 62 बाइट्स ), या वैकल्पिक रूप से एक फॉर्च्यूनर के साथ, 62 बाइट्स भी: b=>{int s=0,t=1;foreach(int i in b)s+=i*(t^=2);return s%10<1;}(जो कि मेरे जावा 8 उत्तर का एक पोर्ट है )।

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

1

MATLAB / ऑक्टेव , 32 बाइट्स

@(x)~mod(sum([2*x(1:2:7),x]),10)

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

मैं दूसरे ऑक्टेव उत्तर के बावजूद इसे पोस्ट करने जा रहा हूं क्योंकि मैंने अन्य उत्तरों को देखे बिना इस कोड और दृष्टिकोण को विकसित किया है।

यहां हमारे पास एक अनाम फ़ंक्शन है जो इनपुट को 8 मानों की एक सरणी के रूप में लेता है, और यदि एक वैध बारकोड, अन्यथा गलत है तो वापस लौटें।

परिणाम की गणना निम्नानुसार की जाती है।

              2*x(1:2:7)
             [          ,x]
         sum(              )
     mod(                   ,10)
@(x)~

विषम अंक (एक अनुक्रमित) 2 से गुणा किया जाता है।
परिणाम इनपुट सरणी से जुड़ा हुआ है, एक सरणी देता है जिसके योग में तीन बार विषम अंक होंगे, और यहां तक कि एक बार अंक भी।
हम उस राशि को करते हैं जिसमें हमारी राशि के भीतर आपूर्ति की गई चेकसम भी शामिल होगी।
इसके बाद मोडुलो 10 का प्रदर्शन किया जाता है। यदि आपूर्ति की गई चेकसम मान्य थी, तो चेकसम मान सहित सभी गुणा अंकों का योग 10 से अधिक होगा। इसलिए केवल एक वैध बारकोड 0 होगा।
परिणाम सही होने पर तार्किक का तार्किक आउटपुट प्राप्त करने के लिए उलटा है।

— टॉम बढ़ई
स्रोत

1

एक्सेल, 37 बाइट्स

एक्सेल में 8 अलग-अलग सेल की अनुमति के रूप में "8 पूर्णांक की एक सूची" की व्याख्या करना:

=MOD(SUM(A1:H1)+2*(A1+C1+E1+G1),10)=0

— Wernisch
स्रोत

= MOD (SUM (A1: H1) + 2 * (A1 + C1 + E1 + G1)), 10) = 0 यह सूत्र एक्सेल में मौजूद है?

— रोजलूपी

@RosLuP, पूर्वनिर्धारित नहीं, नहीं। लेकिन मोडुलो, सम, + आदि करते हैं ;-)

— वर्निश

मैं केवल यह कहना चाहता हूं कि ऐसा लगता है कि एपीएल में पहले y = (A1: H1) + 2 * (A1 + C1 + E1 + G1), और योग और मॉड के बाद अच्छा हो रहा है; एपीएल में पहले योग (A1: H1) आदि कुछ (1,2,3) + 4 = (5,6,7) और सम (5,6,7) = 18 से आगे नहीं जाते हैं; ध्यान दें कि राशि (१,२,३) = ६ और ६ + ४ = १० १ 18 से अलग। लेकिन संभव है कि मैं किसी चीज में त्रुटि

— करूं

@RosLuP, क्षमायाचना, ()आपकी टिप्पणी में परिवर्तित s को याद किया ।

— वार्निस्क

समस्या यह है कि एक्सेल की व्याख्या कैसे की जाती है =(A1:H1): यह एक सरणी के रूप में नियंत्रित नहीं किया जाता है। किसी भी कॉलम में A-Hसीमा में नहीं होने पर अमान्य है । यदि AH में एक कॉलम में रखा जाता है, तो केवल उस कॉलम के लिए मान लौटाता है। (फॉर्मूला% में% परिणाम: C2 -> C1 H999 -> H1 K1 -> #VALUE!)

— Wernisch

1

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

पूर्णांक की एक सरणी लेता है। -6 बाइट्स जॉर्डन के लिए धन्यवाद।

->n{n.zip([3,1]*4){|x,y|$.+=x*y};$.%10<1}

— प्रदर्शित होने वाला नाम
स्रोत

अच्छा! FWIW आप mapयहाँ बिल्कुल ज़रूरत नहीं है : zipएक ब्लॉक लेता है। आप $.इनिशियलाइज़ करने के बजाए कुछ और बाइट्स बचा सकते हैं s:->n{n.zip([3,1]*4){|x,y|$.+=x*y};$.%10<1}

— जॉर्डन

1

टीआई-बेसिक (83 श्रृंखला), 18 बाइट्स

not(fPart(.1sum(2Ans-Ans9^cumSum(binomcdf(7,0

में एक सूची के रूप में इनपुट लेता है Ans। 1वैध बारकोड और 0अमान्य लोगों के लिए रिटर्न ।

मेरे गणितज्ञ उत्तर का एक बंदरगाह । स्क्रीनशॉट शामिल है, एक ऑनलाइन परीक्षण वातावरण के बदले में:

उल्लेखनीय विशेषता: binomcdf(7,0का उपयोग सूची बनाने के लिए किया जाता है {1,1,1,1,1,1,1,1}(संभावनाओं की सूची जो सफलता की संभावना 0 के साथ 7 परीक्षणों से, एन = 0,1, ..., 7) के लिए अधिकांश एन सफलताओं पर होगी। फिर, cumSum(इस में बदल जाता है {1,2,3,4,5,6,7,8}।

यह seq(कमांड का उपयोग करने से एक बाइट कम है , हालांकि ऐतिहासिक रूप से मुद्दा यह था कि यह काफी तेज है।

— मिशा लावरोव
स्रोत

क्या मेरा बारकोड वैध है?

चुनौती

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

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

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

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

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

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

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

यह कैसे काम करता है

MATL , 10 बाइट्स

व्याख्या

बेफ़ुंज -98 (PyFunge) , 16 14 बाइट्स

व्याख्या

क्रमशः

सी, 78 77 बाइट्स

सी (जीसीसी), 72 बाइट्स

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 26 21 बाइट्स

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

वोल्फ्राम भाषा (गणितज्ञ) , 33 बाइट्स और गैर-प्रतिस्पर्धात्मक

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

जावा 8, 58 56 55 बाइट्स

05AB1E , 14 बाइट्स

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

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

यह कैसे काम करता है?

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

रेटिना , 23 22 बाइट्स

व्याख्या

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

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

APL (Dyalog) , 14 बाइट्स

05AB1E , 9 बाइट्स

जे, 17 बाइट्स

मूल, 27 बाइट्स

व्याख्या की

सी (जीसीसी), 84 82 72 61 54 बाइट्स

सी, 63 बाइट्स

बेहतर वापसी मूल्य के लिए +3 बाइट्स

Ungolfed

Steadybox, 63 बाइट्स द्वारा सुझाए गए लूप के अंदर प्रारंभिक चर

Steadybox, 61 बाइट्स द्वारा सुझाए अनुसार घुंघराले कोष्ठक को हटा दें

केविन क्रूज़सेन द्वारा सुझाए गए बेहतर रिटर्न मूल्य के <1बजाय उपयोग करना==0

जावास्क्रिप्ट (Node.js) , 47 बाइट्स

परिक्षण

पर्ल 5, 37 32 + 1 (-पी) बाइट्स

ब्रेनफक, 228 बाइट्स

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

जावा 8, 53 बाइट्स

QBasic, 54 52 बाइट्स

सी # (.NET कोर) , 65 62 बाइट्स

स्वीकृतियाँ

DeGolfed

सी # (.NET कोर) , 53 बाइट्स

MATLAB / ऑक्टेव , 32 बाइट्स

एक्सेल, 37 बाइट्स

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

टीआई-बेसिक (83 श्रृंखला), 18 बाइट्स

केविन क्रूज़सेन द्वारा सुझाए गए बेहतर रिटर्न मूल्य के `<1`बजाय उपयोग करना`==0`