क्रेडिट कार्ड नंबर की पुष्टि करने के लिए Luhn एल्गोरिथ्म, आदि

49

चुनौती

सत्यापन (क्रेडिट कार्ड) संख्याओं के लिए Luhn एल्गोरिथम की गणना करने के लिए सबसे छोटा प्रोग्राम या फ़ंक्शन लिखें ।

Luhn एल्गोरिथ्म समझाया

RosettaCode से , इस चुनौती के प्रयोजनों के लिए इस एल्गोरिथ्म को इस प्रकार निर्दिष्ट किया गया है, उदाहरण इनपुट के साथ 49927398716:

Reverse the digits, make an array:
    6, 1, 7, 8, 9, 3, 7, 2, 9, 9, 4
Double the numbers in odd indexes:
    6, 2, 7, 16, 9, 6, 7, 4, 9, 18, 4
Sum the digits in each number:
    6, 2, 7, 7, 9, 6, 7, 4, 9, 9, 4
Sum all of the numbers:
    6 + 2 + 7 + 7 + 9 + 6 + 7 + 4 + 9 + 9 + 4 = 70
If the sum modulo 10 is 0, then the number is valid:
    70 % 10 = 0 => valid

IO नियम

इनपुट : अपनी भाषा के इनपुट / आउटपुट फॉर्मेट में एक स्ट्रिंग या संख्या (आपकी पसंद)

आउटपुट : एक सत्य या मिथ्या मूल्य , क्रमशः, यह दर्शाता है कि ऊपर परीक्षण के अनुसार इनपुट वैध है या नहीं।

नोट्स / टिप्स

  • यदि आप परीक्षण करने के लिए उपयोग करते हैं, तो गलती से अपने क्रेडिट कार्ड या खाता संख्या को पोस्ट करने की कोशिश न करें :)

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

  • हालांकि , पिछली गोली का मतलब यह नहीं है कि आपकी भाषा नंबरों के साथ जो चाहे कर सकती है जो इसे संभालने के लिए बहुत बड़ी है। यदि आपकी भाषा परीक्षण के मामले को संभालने में सक्षम नहीं है, तो इनपुट के रूप में एक स्ट्रिंग लेने पर विचार करें।

उदाहरण

निम्नलिखित उदाहरण इस पायथन लिपि के साथ मान्य किए गए थे ; अगर आपको लगता है कि एक गलत है या एक सवाल है, तो बस @cat पिंग करें।

49927398716      True
49927398717      False
1234567812345670 True    
1234567812345678 False
79927398710      False
79927398711      False
79927398712      False
79927398713      True
79927398714      False
79927398715      False
79927398716      False
79927398717      False
79927398718      False
79927398719      False
374652346956782346957823694857692364857368475368 True
374652346956782346957823694857692364857387456834 False
8 False **
0 True  **

** पायथन कार्यान्वयन के अनुसार, लेकिन आप कुछ भी कर सकते हैं क्योंकि ये विनिर्देश के सख्त पालन के योग्य होने के लिए बहुत कम हैं।

यदि उपरोक्त में से कोई भी मौजूदा उत्तरों को अमान्य करता है (हालांकि मेरा मानना ​​है कि यह संभव नहीं होना चाहिए), तो वे उत्तर मान्य मान्य हैं। हालांकि, नए उत्तर, मान्य होने के लिए, ऊपर दिए गए विनिर्देश का पालन करना चाहिए।

लीडरबोर्ड

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

code-golf  arithmetic  checksum 
— क्रिस लाप्लांटे
स्रोत

जवाबों:

21

गोल्फस्क्रिप्ट - 24 वर्ण

-1%{2+0!:0)*109%+}*10%8=

स्पष्टीकरण:

  1. -1% स्ट्रिंग को उलट देता है
  2. {एक ब्लॉक शुरू होता है (जिसे हम लूप के रूप में उपयोग करते हैं)। स्ट्रिंग्स में प्रत्येक चरित्र को आस्की मूल्य के रूप में धकेल दिया जाता है।
    1. 2+ 2 जोड़ता है (किसी अंक का एससीआई मान 48 + n है, इसलिए हमारे पास अभी 50 + n है और अंतिम अंक n है)
    2. 0!:0 0 का मान निकालता है और इसे स्टोर करता है (सब कुछ एक चर है), इसलिए हमारे पास पहले पुनरावृत्ति पर 1, दूसरे पर 0, आदि हैं।
    3. )* इस मान में एक जोड़ता है और इसे गुणा करता है, इसलिए हम 2 से गुणा करते हैं, फिर 1, फिर 2, आदि।
    4. 109% शेष मोडुलो 109 है। यह केवल 5-9 मूल्यों को प्रभावित करता है जिन्हें दोगुना कर दिया गया है और उन्हें सही मूल्य तक कम कर देता है।
    5. + इस मान को रनिंग योग में जोड़ता है
  3. }*ब्लॉक को समाप्त करता है और एक 'गुना' ऑपरेशन करता है। सबसे पहले, पहले वर्ण को धकेल दिया जाता है (क्योंकि हमने उलट कर दिया है, यह चेक अंक है)। फिर, ब्लॉक को आगे बढ़ाने और निष्पादित करने के लिए वैकल्पिक। इस प्रकार, हम पहले अक्षर की एससीआई मान का उपयोग कर रहे हैं, जो चल रहे योग के लिए शुरुआती मूल्य है।
  4. 10% शेष मोडुलो 10 लेता है।
  5. 8= 1 वापस आएगा यदि मान 8 है। हम इसका उपयोग करते हैं क्योंकि हमने पहले धकेलने वाले चरित्र (चेक अंक) को सामान्य नहीं किया था।

एक सोच सकते हैं कि हम इस्तेमाल कर सकते हैं 8-बजाय 2+बदलकर एक चरित्र को बचाने के लिए 109%करने के लिए 89%, को छोड़कर फिर हम एक अंतरिक्ष जोड़ने के लिए की आवश्यकता होगी तो -घटाव (बजाय है -0)।

— Nabb
स्रोत
11

GolfScript, 44 वर्ण

-1%{16%}%2/1,\+{(\.{0=2*.9>9*-+}{;}if+}*10%!

चयनित टिप्पणी

दिलचस्प है, नीचे के पहले दो आइटम %ऑपरेटर के तीन पूरी तरह से अलग-अलग उपयोगों को प्रदर्शित करते हैं : सरणी चयन, मानचित्र और मॉड। अधिकांश गोल्फस्क्रिप्ट संचालक "संदर्भ-संवेदनशील" हैं, उन्हें किस प्रकार के तर्क हैं, इस पर निर्भर करते हुए बेहद भिन्न व्यवहार देते हैं।

  1. -1%स्ट्रिंग को उलट देता है। यह महत्वपूर्ण है क्योंकि अंक जोड़े दाईं ओर से गिने जाते हैं।
  2. {16%}% सभी ASCII अंकों को 16 के साथ संशोधित करके संख्याओं में परिवर्तित करता है।
  3. 2/ सरणी को 2 के समूहों में विभाजित करता है।
  4. 1,एक सस्ता तरीका है [0]।
  5. \+प्रभावी ढंग से अंक सरणी के लिए 0 prepends। यह अदला-बदली करके तब होता है।

अगले में आने वाले फोल्ड की तैयारी में 0 का इस्तेमाल किया जाता है। एक स्पष्ट प्रारंभिक मूल्य लेने के बजाय, गोल्फस्क्रिप्ट का गुना प्रारंभिक मूल्य के रूप में सरणी में पहले आइटम का उपयोग करता है।

अब, हम वास्तविक गुना फ़ंक्शन को देखते हैं। यह फ़ंक्शन दो तर्क लेता है: मुड़ा हुआ मूल्य, और सरणी पर वर्तमान आइटम (जो इस मामले में 2 या (असामान्य रूप से) 1 का एक सरणी होगा, 2/पहले की वजह से )। मान लेते हैं कि तर्क हैं 1 [2 3]।

  1. (\.बाईं ओर सरणी तत्व को विभाजित करता है, शेष सरणी को सामने की ओर ले जाता है, फिर उसे कॉपी करता है। स्टैक अब जैसा दिखता है 1 2 [3] [3]:।
  2. ifजांच करता है कि सरणी रिक्त है (जो पिछले समूह जब एक अजीब आकार खाता संख्या से निपटने के लिए मामला है)। यदि ऐसा है, तो कोई विशेष प्रसंस्करण नहीं होता है (बस खाली सरणी बंद करें)।
  3. एक सम समूह के लिए:
    1. 0= सरणी के पहले (केवल, इस मामले में) तत्व को पकड़ लेता है। 1 2 3
    2. 2* संख्या दोगुनी कर देता है। 1 2 6
    3. .9>9*- संख्या से 9 घटाएँ यदि यह 9 से अधिक है। जैसा कि लागू किया गया है: संख्या की प्रतिलिपि बनाएँ, 9 के साथ तुलना करें, परिणाम को 9 से गुणा करें (जो या तो 0 या 1 है), फिर घटाएं। 1 2 6
    4. + अंत में इसे पहले नंबर पर जोड़ देता है। 1 8
  4. +(के बाद if) ifमूल मूल्य का परिणाम जोड़ता है , जिसके परिणामस्वरूप नया मुड़ा हुआ मूल्य होता है।

तह पूरा होने के बाद, हम बस 10 ( 10%) के साथ मॉड करते हैं , और परिणाम ( !) को नकारते हैं , जिससे कि हम 1 iff वापस करते हैं, तो योग 10 का गुणक है।

— क्रिस जस्टर-यंग
स्रोत
यह wikipedia (49927398716) पर उदाहरण संख्या के लिए 0 लौटा लगता है
— gnibbler
एनएम। मैं उपयोग करना भूल गयाecho -n
— gnibbler
1
@gnibbler: हाहा, विफल। :-P (गंभीरता से, मैं अपने प्रारंभिक परीक्षण में उस एक के द्वारा अटक गया।)
— क्रिस जस्टर-यंग
1
यहां कुछ आसान पात्रों को सहेजने के लिए कुछ स्थान। -1% 2/में संयुक्त किया जा सकता है -2/। 1,के साथ प्रतिस्थापित किया जा सकता है 0(0 एक सरणी के लिए मजबूर किया जाता है, फिर +संक्षिप्त है)। 9>9*-के साथ प्रतिस्थापित किया जा सकता है 9>+(क्योंकि हम केवल अंतिम अंक से संबंधित हैं)। इसके अलावा, विषम लंबाई की जाँच थोड़ी लंबी है, इसका उपयोग .,2%,\+कम है। यह करने के बाद, हम भी बदल सकते हैं {16%}%और (\0=में {16}/(पाश अंदर)। एक बार जब आप यह सब कर लिया, तो कुछ इस तरह दिखाई देंगे: .,2%,\+-2/0\+{{16%}/2*.9>+++}*10%!।
— नबंवर
@ नब: धन्यवाद! मैं उन लोगों को अपने समाधान में शामिल करूंगा, हालांकि ऐसा लगता है कि आपके पास पहले से ही एक है जो गंभीर गधे को मार रहा है। :-)
— क्रिस जस्टर-यंग
11

पायथन, 73 69 वर्ण

def P(x):D=map(int,x);return sum(D+[d-d/5*9for d in D[-2::-2]])%10==0
— कीथ रान्डेल
स्रोत
4
आप पीछे की ओर लूप न करके दो और चार्ट बचा सकते हैं: D[-2::-2]-> D[1::2]जैसे कि राशि का क्रम महत्वपूर्ण नहीं है :)
— ThinkChaos
==0को छोटा किया जा सकता है<1
— ब्लैक उल्लू काई
9

C # 119 वर्ण:

bool l(string n){return(String.Join("",n.Reverse().Select((x,i)=>(x-48)*(i%2<1?1:2)+"").ToArray()).Sum(x=>x-48))%10<1;}

एक कोड गोल्फ n00b के लिए एक खराब टाइप भाषा में बहुत बुरा नहीं है , मुझे उम्मीद है।

इसे घटाकर 100 किया जा सकता है :

bool l(string n){return String.Join("",n.Reverse().Select((x,i)=>(x-48)*(i%2+1))).Sum(x=>x+2)%10<1;}
— mootinator
स्रोत
यह एक अच्छा विचार है, और एक दिलचस्प तरीका है, लेकिन यह काम नहीं करता है। कम से कम मेरे कुछ परीक्षणों के साथ नहीं। ऐसा लगता है कि आपके पहले लैम्ब्डा में "i" को स्ट्रिंग में वर्ण का सूचकांक माना जाता है। क्या वह वैसा ही काम करता है जैसा उसे करना चाहिए? यदि हां, तो आप केवल अनुक्रमणिका स्थिति के आधार पर इसे संशोधित करने के लिए स्ट्रिंग को उल्टा क्यों करते हैं? थोड़ा बेमानी लगता है, नहीं?
— नेलियस
मैंने केवल अपने क्रेडिट कार्डों में से एक का परीक्षण किया और कुछ टीबीएच से एक त्रुटि के कारण। (वीएस 2008 डीबगर का उपयोग करके) एल्गोरिथ्म को लास्ट अंक के साथ शुरू होने वाले हर दूसरे अंक को दोगुना करना है। अगर मैंने स्ट्रिंग को उल्टा नहीं किया, तो यह विषम लंबाई वाले तारों के लिए गलत होगा।
— मूटिनेटर
पता चलता है कि मैं i%2<1?1:2पीछे की ओर परिणाम था । धन्यवाद।
— भूतकाल
8

गोल्फस्क्रिप्ट - 34 वर्ण

{15&}%.-2%\);-2%{.+(9%)}%+{+}*10%!

विकिपीडिया पृष्ठ 4992739871 से उदाहरण संख्या

{15&}%  does a bitwise and of each ascii digit with 00001111
        now I have a list of digits 
        [4 9 9 2 7 3 9 8 7 1 6]
.       makes a copy of the list, now I have two identical lists
        [4 9 9 2 7 3 9 8 7 1 6] [4 9 9 2 7 3 9 8 7 1 6]
-2%     like [::-2] in python takes every second element in reverse
        [4 9 9 2 7 3 9 8 7 1 6] [6 7 9 7 9 4]
\       swap the two lists around
        [6 7 9 7 9 4] [4 9 9 2 7 3 9 8 7 1 6]
);      drop the last digit off the list
        [6 7 9 7 9 4] [4 9 9 2 7 3 9 8 7 1]
-2%     same as before
        [6 7 9 7 9 4] [1 8 3 2 9]
{       for each item in the list ...
.+      ... double it ...
(       ... subtract 1 ...
9%      ... mod 9 ...
)}%     ... add 1 ...
        [6 7 9 7 9 4] [2 7 6 4 9]
+       join the two lists
        [6 7 9 7 9 4 2 7 6 4 9]
{+}*    add the elements up
        70
10%     mod 10
        0
!       invert the result
        1
— gnibbler
स्रोत
.+(9%)बहुत अभिनव (मेरे लिए, वैसे भी) है। मुझे पसंद है! +1
— क्रिस जस्टर-यंग
हालांकि, गोल्फस्क्रिप्ट को एक विभाजन ऑपरेटर की आवश्यकता होती है, इसलिए आपको यह "ड्रॉप एंड आइटम ऑफ और रिपीट" बकवास करने की आवश्यकता नहीं है। :-)
— क्रिस जस्टर-यंग
1
@ क्रिस, मुझे पता चला कि कई साल पहले "कास्टिंग आउटिंग" कहा जाता था। यह लंबे समय तक जोड़ने और गुणा करने का दोहरा तरीका है
— gnibbler
3
यह 0 के मूल्य के लिए दोगुना नहीं होगा ( 0(9%)9 है और 0 नहीं है)।
— नबंर
8

PHP, 108 बाइट्स

<?function v($s,$t=0){for($i=strlen($s);$i>=0;$i--,$c=$s[$i])$t+=$c+$i%2*(($c>4)*-4+$c%5);return!($t % 10);}
— जुआन
स्रोत
7

रूबी - 85 अक्षर

def f s
l=s.size
s.chars.map{|k|(i=k.to_i*((l-=1)%2+1))%10+i/10}.inject(:+)%10==0
end
— Nemo157
स्रोत
आप शायद इस बारे में जानते हैं, लेकिन आप 7 बाइट्स बचाने के लिए .inject (: +) की जगह .sum कर सकते हैं
— Håvard Nygård
7

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

बेहतर / छोटा तरीका होना चाहिए, लेकिन यहां 96 वर्णों में मेरा हास्केल समाधान है :

l=(==0).(`mod`10).sum.zipWith($)(cycle[id,\x->x`mod`5*2+x`div`5]).reverse.map((+(-48)).fromEnum)

अफसोस की बात है कि digitToIntफ़ंक्शन का उपयोग केवल तभी किया जा सकता है जब आप import Data.Charपहले। अन्यथा मैं 88 वर्णों के ((+(-48)).fromEnum)साथ बदल सकता था digitToInt।

— sepp2k
स्रोत
6

विंडोज पॉवरशेल, 82

filter f{!((''+($_[($_.length)..0]|%{+"$_"*($i++%2+1)})-replace'.','+$&'|iex)%10)}

इतिहास:

  • 2011-02-13 03:08 (84) पहला प्रयास।
  • 2011-02-13 12:13 (82) मुझे इसमें शामिल होने की आवश्यकता नहीं है, क्योंकि रिक्त स्थान चोट नहीं पहुंचाते हैं। +1 + +3अभी भी मूल्यांकन किया जा सकता है।
— एक छोटा सा सिक्का
स्रोत
5

क्यू, ६३

{0=mod[(+/)"I"$(,/)($)($)@["I"$'x;1+2*'(!)(_)((#)x)%2;*;2];10]}

प्रयोग

q){0=mod[(+/)"I"$(,/)($)($)@["I"$'x;1+2*'(!)(_)((#)x)%2;*;2];10]}"79927398711"
0b
q){0=mod[(+/)"I"$(,/)($)($)@["I"$'x;1+2*'(!)(_)((#)x)%2;*;2];10]}"79927398712"
0b
q){0=mod[(+/)"I"$(,/)($)($)@["I"$'x;1+2*'(!)(_)((#)x)%2;*;2];10]}"79927398713"
1b
— tmartin
स्रोत
47 {0=mod[sum"J"$raze($)($)x*#:[x]#1 2]10}"I"$'(|)सूचकांकों को विषम सूचक को दोगुना करने के लिए एक अलग तरीके से।
— सड़क
5

डी, 144 बाइट्स

bool f(S)(S s){int t(C)(C c){return to!int(c)-'0';}int n,v;foreach(i,c;array(retro(s))){v=i&1?t(c)*2:t(c);n+=v>=10?v%10+v/10:v;}return n%10==0;}

अधिक कानूनी रूप से:

bool f(S)(S s)
{
    int t(C)(C c)
    {
        return to!int(c) - '0';
    }

    int n, v;

    foreach(i, c; array(retro(s)))
    {
        v = i & 1 ? t(c) * 2 : t(c);

        n += v >= 10 ? v % 10 + v / 10 : v;
    }

    return n % 10 == 0;
}
— जोनाथन एम डेविस
स्रोत
5

एपीएल, 28 बाइट्स

{0=10|+/⍎¨∊⍕¨v×⌽2-2|⍳⍴v←⍎¨⍵}

विस्फोट देखें

{                     v←⍎¨⍵}  ⍝ turn the string into a numeric vector of its digits, v
                2-2|⍳⍴v       ⍝ make a vector of the same length, with 2 in every 2nd place
             v×⌽              ⍝ multiply it with v, starting from the right
          ∊⍕¨                 ⍝ turn each component into a string and collect all the digits
      +/⍎¨                    ⍝ turn each digit again into a number and sum them
 0=10|                        ⍝ check whether the sum is a multiple of 10

उदाहरण

      {0=10|+/⍎¨∊⍕¨v×⌽2-2|⍳⍴v←⍎¨⍵} '79927398713'
1
      {0=10|+/⍎¨∊⍕¨v×⌽2-2|⍳⍴v←⍎¨⍵} '123456789'
0
— Tobia
स्रोत
1
-2:{0=10|+/⍎¨∊⍕¨⍵×⌽2-2|⍳⍴⍵}⍎¨
— अदाम
4

पर्ल, 46 42 41 बाइट्स

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

STDIN पर इनपुट दें:

luhn.pl <<< 79927398713

luhn.pl:

#!/usr/bin/perl -p
s%.%$=-=-$&-$&*1.2*/\G(..)+$/%eg;$_=/0$/
— टन हास्पेल
स्रोत
क्या आप बता सकते हैं कि यह कैसे काम करता है? आप मैच के हिसाब से घटते जा रहे हैं और फिर मैच के समय 1.2 से लेकिन केवल सही स्थिति में हैं। 1.2 क्यों? यह नहीं होना चाहिए $=-=-$&-$&*/\G(..)+$/?
— msh210
3
@ msh210: यह गुणन के प्रभाव को 0..42 से जोड़ता है। * 2 देता है 0, 2, 4, 6, 8लेकिन 5..9वह 10,12,14,16,18राशि देता है जिसके 1 3 5 7 9समान अंतिम अंक 11 13 15 17 19होते हैं जो समान मान होते हैं जैसे 0..9 * 2.2कि आप पूर्णांक को काटते हैं। पहले से $&ही पहले से ही एक कारक का योगदान है 1, इसलिए 1.2अभी भी सुधार की आवश्यकता है। $=केवल पूर्णांकों को पकड़ सकता है और एक मान से शुरू होता है जो 0 पर समाप्त होता है इसलिए ट्रंकटिंग का ध्यान रखता है। नकारात्मक मूल्यों की आवश्यकता है क्योंकि /\G/रेगेक्स $&मूल्यांकन स्टैक पर किसी भी परिवर्तन को बदल देता है, इसलिए उन्हें बदलने की आवश्यकता है
— टन हास्पेल
ओह। प्रतिभाशाली! और स्पष्टीकरण के लिए धन्यवाद।
— msh210
3

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

गैर-प्रतिस्पर्धा, चूंकि 2011 में जावास्क्रिप्ट बहुत अलग थी।

अंकों का योग 2*nहै 2*nयदि n in 0..4, 2*n-9यदि n in 5..9। उन्होंने कहा, सभी योगों की गणना एक चरण में की जा सकती है।

s=>!([...s].reduceRight((t,d)=>t-d-i++%2*(d>4?d-9:d),i=0)%10)
— edc65
स्रोत
3

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

ṚḤJḤ$¦DFS⁵ḍ

इसे ऑनलाइन आज़माएं! (सभी परीक्षण मामलों के साथ)

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

ṚḤJḤ$¦DFSḍ⁵  - Main link. Argument: n (integer) e.g. 49927398716
Ṛ            - Reverse. Casts a number to digits     [6, 1, 7, 8, 9, 3, 7, 2, 9, 9, 4]
     ¦       - Sparse application. Apply the next command to the given indicies
 Ḥ           -   Command: Double
    $        -   Indicies:
  J          -     range(length)...                  [1, 2 , 3, 4, 5, 6, 7, 8, 9, 10, 11]
   Ḥ         -     doubled.                          [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22]
             - Doubles elements at odd indicies      [6, 2, 7, 16, 9, 6, 7, 4, 9, 18, 4]
      D      - Split each into digits                [6, 2, 7, [1, 6], 9, 6, 7, 4, 9, [1, 8], 4]
       F     - Flatten                               [6, 2, 7, 1, 6, 9, 6, 7, 4, 9, 1, 8, 4]
        S    - Sum                                   70
          ḍ  - Divisible by... 
         ⁵   -   10?                                 1

वैकल्पिक रूप से, 12 बाइट्स के लिए:

ṚḤJḤ$¦DFSḍ@⁵
— केर्ड सिक्काहिरिंग
स्रोत
3

8086 विधानसभा , आईबीएम पीसी डॉस,29 28 25 23 बाइट्स

; Perform LUHN check
; Input: SI = card num string, CX = length
; Output: ZF = 1 if valid, ZF = 0 if not valid
    LUHN    MACRO
            LOCAL DIGIT_LOOP, EVEN
03 F1       ADD  SI, CX         ; start at end of input string 
FD          STD                 ; set LODSB direction to decrement 
    DIGIT_LOOP:
AC          LODSB               ; load next digit into AL, decrement SI
2C 30       SUB  AL, '0'        ; convert ASCII char to binary value 
F7 DA       NEG  DX             ; flip DX to alternate odd/even index
78 06       JS   EVEN           ; if even index, do not double and sum digits 
D0 E0       SHL  AL, 1          ; double the value 
D4 0A       AAM                 ; BCD convert to split digits (ex: 18 = 12H --> 0108H) 
02 DC       ADD  BL, AH         ; add tens digit to running sum 
    EVEN:
02 D8       ADD  BL, AL         ; add ones digit to running sum 
E2 ED       LOOP DIGIT_LOOP 
93          XCHG BX, AX         ; sum is in BL, move to AL for conversion
D4 0A       AAM                 ; BCD convert AL, set ZF=1 if low digit is 0
    ENDM

व्यक्तिगत अंकों के विभाजन और modulo 10जांच को संभालने के लिए x86 के बीसीडी-टू-बाइनरी निर्देशों का उपयोग (दुरुपयोग) करता है । यह पता चलता है कि AAMऔर AADनिर्देश बाइट मानों के बीसीडी / द्विआधारी रूपांतरण (जो बहुत काम आ सकते हैं) करते हैं, इसके बावजूद कि उन्हें दस्तावेज के रूप में प्रस्तुत नहीं किया जाता है या उस कार्य को उदारतापूर्वक किया जाता है।

सभी सरकारी आईबीएम / एमएस डॉस संस्करणों के लिए, AXऔर BXकरने के लिए प्रारंभ कर रहे हैं 0000स्टार्टअप (पर रेफरी , रेफरी ) और DXकरने के लिए CSहै, जो इतनी गैर शून्य और सकारात्मक होने की गारंटी एक 12 बिट मूल्य है। यह हम कैसे सुनिश्चित कर सकते हैं है BXहै 0और फ्लिप / फ्लॉप कर सकते हैं DXअजीब / भी अंक स्थानों का निर्धारण करने के लिए।

उदाहरण आउटपुट:

यहाँ छवि विवरण दर्ज करें

LUHN.COM आईबीएम पीसी डॉस परीक्षण कार्यक्रम डाउनलोड करें ।

— 640KB
स्रोत
2

स्काला: 132

def q(x:Int)=x%10+x/10
def c(i:String)={val s=i.reverse
(s(0)-48)==10-(s.tail.sliding(2,2).map(n=>(q((n(0)-48)*2)+n(1)-48)).sum%10)}

मंगलाचरण:

c("79927398713")
  • रिवर्स ("79927398713") = 31789372997
  • s (0), s.tail: (3) (1789372997)
  • स्लाइडिंग (2,2) = (17 89 37 29 97)
  • नक्शा (q ((n (0) -48 * 2 + n (1) -48)) => q (('1' - '0') * 2) + '7' - '0') = 1 * 2 + 7
— अज्ञात उपयोगकर्ता
स्रोत
2

जावास्क्रिप्ट 1.8: 106 अक्षर

यह एक मूल समाधान है जो मैंने इस पोस्ट को प्राप्त करने से पहले दिया था:

function(n){return!(n.split('').reverse().reduce(function(p,c,i){return(+c&&((c*(1+i%2)%9)||9))+p},0)%10)}

पठनीय रूप:

function luhnCheck(ccNum) {
    return !(                                  // True if the result is zero.
             ccNum.split('').
               reverse().                      // Iterate over the string from rtl.
               reduce(function(prev, cur, idx) {
                 return prev +                 // Sum the results of each character.
                        (+cur &&               // If the current digit is 0, move on.
                         ((cur * (1 + idx % 2) // Double cur at even indices.
                           % 9) || 9));        // Sum the digits of the result.
               }, 0)
            % 10);                             // Is the sum evenly divisible by 10?
}
— Kojiro
स्रोत
2

रेटिना , 43 42 बाइट्स

इस चुनौती की तुलना में रेटिना (बहुत) नया है।


;
r`(.);.
$1$&
\d
$*
1+
$.&
.
$*
$
$._
0$

अग्रणी खाली लाइन महत्वपूर्ण है।

0झूठे और 1सत्य परिणामों के लिए प्रिंट ।

इसे ऑनलाइन आज़माएं! (सभी परीक्षण मामलों को एक साथ चलाने के लिए थोड़ा संशोधित किया गया है।)

व्याख्या


;

;अंकों को अलग करने के लिए हर स्थिति में डालें ।

r`(.);.
$1$&

से right, हम बार-बार दो अंक और डबल बाईं एक मेल खाते हैं। इस तरह हम सूची के महंगे उलटने से बचते हैं।

\d
$*

हम प्रत्येक अंक से मेल खाते हैं और इसे कई 1s में परिवर्तित करते हैं (अर्थात, हम प्रत्येक अंक को एक में परिवर्तित करते हैं)।

1+
$.&

यह प्रत्येक यूनरी संख्या से मेल खाता है और इसे अपनी लंबाई के साथ बदलकर दशमलव में परिवर्तित करता है। पिछले चरण के साथ, यह दोहरे अंकों को जोड़ता है।

.
$*

फिर से, हम हर चरित्र से मेल खाते हैं और इसे कई 1एस में बदल देते हैं । यही कारण है कि हम प्रत्येक अंक को अलग-अलग वापस एकात्मक में परिवर्तित करते हैं। यह ;विभाजकों से भी मेल खाता है , जिन्हें रूपांतरण में शून्य के रूप में माना जाता है, जिसका अर्थ है कि वे बस हटा दिए गए हैं। चूँकि सभी एकात्मक संख्याएँ अब एक साथ मिल गई हैं, इसलिए हमने सभी अंकों के संयुक्त प्रतिनिधित्व को स्वचालित रूप से जोड़ दिया है।

$
$._

अंत में, हम पूरे स्ट्रिंग की लंबाई को सम्मिलित करते हैं, अर्थात यूरी चेकसम के दशमलव प्रतिनिधित्व।

0$

अंत में हम इस रेगेक्स के मैचों की संख्या की गणना करते हैं, अर्थात हम जांचते हैं कि दशमलव का प्रतिनिधित्व 0मुद्रण 0या उसके 1अनुसार समाप्त होता है या नहीं ।

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

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

param($s)$s[$s.Length..0]|%{(1+$i++%2)*"$_"}|%{$r+=$_-9*($_-gt9)}
!($r%10)

व्याख्या

  1. एक तर्क स्ट्रिंग के प्रत्येक चार के लिए, रिवर्स ऑर्डर में
  2. एक अंक के दोहरे मूल्य का एक अंक प्राप्त करें
  3. किसी अंक का दोहरा मान 18 से अधिक नहीं हो सकता है। इसलिए, हम मान> 9 यदि मान> 9 जमा करते हैं
  4. यदि 10 से शेष भाग 0 है तो सही लौटें

टेस्ट स्क्रिप्ट

$f = {

param($s)$s[$s.Length..0]|%{(1+$i++%2)*"$_"}|%{$r+=$_-9*($_-gt9)}
!($r%10)

}

@(
    ,("49927398716"      , $True)
    ,("49927398717"      , $False)
    ,("1234567812345670" , $True)
    ,("1234567812345678" , $False)
    ,("79927398710"      , $False)
    ,("79927398711"      , $False)
    ,("79927398712"      , $False)
    ,("79927398713"      , $True)
    ,("79927398714"      , $False)
    ,("79927398715"      , $False)
    ,("79927398716"      , $False)
    ,("79927398717"      , $False)
    ,("79927398718"      , $False)
    ,("79927398719"      , $False)
    ,("374652346956782346957823694857692364857368475368" , $True)
    ,("374652346956782346957823694857692364857387456834" , $False)
    ,("8" , $False)
    ,("0" , $True)
) | % {
    $s, $expected = $_
    $result = &$f $s
    "$($result-eq$expected): $result : $s"
}

उत्पादन

True: True : 49927398716
True: False : 49927398717
True: True : 1234567812345670
True: False : 1234567812345678
True: False : 79927398710
True: False : 79927398711
True: False : 79927398712
True: True : 79927398713
True: False : 79927398714
True: False : 79927398715
True: False : 79927398716
True: False : 79927398717
True: False : 79927398718
True: False : 79927398719
True: True : 374652346956782346957823694857692364857368475368
True: False : 374652346956782346957823694857692364857387456834
True: False : 8
True: True : 0
— Mazzy
स्रोत
1

GNU सेड, 140 बाइट्स

( -rझंडे के लिए +1 सहित )

s/^(..)*.$/0&/
s/(.)./\1x&/g
s/x[5-9]/1&/g
s/[0x]//g
s/[789]/&6/g
s/[456]/&3/g
s/[369]/&11/g
s/[258]/&1/g
s/.{10}//g
s/.+/false/
s/^$/true/

अंकगणित अंकगणित के लिए लगभग सबसे स्वाभाविक भाषा नहीं है, लेकिन यहाँ हम जाते हैं:

#!/bin/sed -rf

# zero-pad to even length
s/^(..)*.$/0&/
# double every other digit
s/(.)./\1x&/g
# add carry (converts mod-9 to mod-10)
s/x[5-9]/1&/g
# convert sum to unary
s/[0x]//g
s/[789]/&6/g
s/[456]/&3/g
s/[369]/&11/g
s/[258]/&1/g
# remove whole tens
s/.{10}//g
# output 'true' or false
s/.+/false/
s/^$/true/
— टोबी स्पाईट
स्रोत
1

एपीएल, 38 बाइट्स

d←10∘⊥⍣¯1⋄{0=10|+/+/d x×1+~2|⍳⍴x←⌽d ⍵}

संख्या के रूप में संख्या की अपेक्षा करता है, न कि एक स्ट्रिंग के रूप में, लेकिन यह केवल इसलिए है क्योंकि tryAPL (समझदारी से) लागू नहीं होता है⍎

और अधिक reducible, मुझे यकीन है ...

— हारून डेविस
स्रोत
1

PHP - 136 वर्ण

function t($c){foreach($a=str_split(strrev($c)) as $k=>&$v){$v=array_sum(str_split(($k % 2)!==0?2*$v:$v));}return !(array_sum($a)% 10);}
— ज्योति
स्रोत
1

MATL , 23 20 बाइट्स (गैर-प्रतिस्पर्धात्मक)

P!Utn:2X\!*t9>+s10\~

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

मान्य संख्या के लिए आउटपुट 1, अन्यथा।

लुइस मेंडो के सुझावों की बदौलत तीन बाइट्स बचाए।

व्याख्या

P       % flip the order of elements
!       % transpose into column vector
U       % convert char matrix to numeric
t       % duplicate the vector
n       % find the length
:       % create a new vector length n (1, 2, 3, ... n)
2       % number literal
X\      % take it mod 2, to make the new vector (1, 2, 1, ..., (n-1) mod 2 +1)
!       % transpose
*       % element-wise product
t       % duplicate
9       % push 9
>       % 1 if it is greater than 9
+       % add the vectors, this makes the last digit of each the same as the sum of the digits
s       % add them
10      % number literal
\       % mod 10
~       % logical 'not' (element-wise)
        % (implicit) convert to string and display
— बी मेहता ने
स्रोत
1

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

DUḤJḤ$¦DS$€S⁵ḍ

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

स्पष्टीकरण:

D              get digits
 U             reverse array
   JḤ$         for every other index,
  Ḥ   ¦        double the value
          €    for each value,
       D $     get the digits
        S$     and sum them
           S   sum the list
            ⁵ḍ check if it's divisible by 10
— ऐली
स्रोत
यह गैर-प्रतिस्पर्धा क्यों है?
— मडकिप २०
@ mudkip201 सही होने पर मुझे सही करें, लेकिन सवाल पूछे जाने पर जेली का यह संस्करण मौजूद नहीं था, इसलिए यह सवाल के लिए मान्य नहीं है।
— इली
3
बहुत यकीन है कि एक आम सहमति थी, जिसमें कहा गया था कि चुनौती के बाद जो भाषाएं बनाई गई हैं, वे किसी भी तरह से 'गैर-प्रतिस्पर्धी' नहीं हैं
— मैडकिप 201
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.