17

कर रहे हैं लोकप्रिय ऐसे Luhn रूप में चेक अंकों एल्गोरिदम और फिर देखते हैं अच्छा उदाहरण के लिए डैम एल्गोरिथ्म हैं,। एल्गोरिथम जैसे लुहान की लोकप्रियता के पीछे एकमात्र संभावित कारण यह है कि उनमें मौजूद कोड गोल्फ कार्यान्वयन है। इसका अर्थ है कि हम एक समुदाय के रूप में बेहतर एल्गोरिदम के गोल्फ कार्यान्वयन प्रदान करके दुनिया को बदलने की शक्ति रखते हैं।

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

यह एल्गोरिथ्म एक ऑपरेशन टेबल के इर्द-गिर्द घूमता है, जो ऑर्डर 10 के कमजोर पूरी तरह से सममित विरोधी क्रासग्रुप होना चाहिए । डैम एल्गोरिथम के बारे में विकिपीडिया लेख में पाया जा सकता है कि ऑपरेशन टेबल वह है जिसे इस चुनौती में उपयोग किया जाना है। पूर्णता के लिए मैं इसे नीचे पुन: प्रस्तुत करूंगा:

    |   0   1   2   3   4   5   6   7   8   9
----+----------------------------------------
0   |   0   3   1   7   5   9   8   6   4   2
1   |   7   0   9   2   1   5   4   8   6   3
2   |   4   2   0   6   8   7   1   3   5   9
3   |   1   7   5   0   9   8   3   4   2   6
4   |   6   1   2   3   0   4   5   9   7   8
5   |   3   6   7   4   2   0   9   5   8   1
6   |   5   8   6   9   7   2   0   1   3   4
7   |   8   9   4   5   3   6   2   0   1   7
8   |   9   4   3   8   6   1   7   2   0   5
9   |   2   5   8   1   4   3   6   7   9   0

संक्षेप में (विवरण के लिए विकिपीडिया लेख देखें ) एल्गोरिथ्म निम्नानुसार काम करता है:

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

आपके प्रोग्राम या फ़ंक्शन को एक स्ट्रिंग को स्वीकार करना चाहिए जिसमें शून्य को छोड़कर कोई भी वर्ण हो सकता है, लेकिन यह केवल स्ट्रिंग में अंकों के साथ ही चिंता करना चाहिए। इसे या तो प्रिंट करना चाहिए (यदि कोई प्रोग्राम) या रिटर्न (यदि कोई फ़ंक्शन है) तो मूल स्ट्रिंग की गणना की गई गणना अंकों के साथ की गई है। यदि आपने एक प्रोग्राम लिखने के लिए चुना है तो प्रोग्राम इनपुट को एक तर्क के रूप में या मानक इनपुट के रूप में स्वीकार कर सकता है। यदि इनपुट स्ट्रिंग खाली है या आपके पास कोई अंक नहीं है, तो आपको एक शून्य वापस करना या जोड़ना होगा।

कुछ उदाहरण:

Input       |   Output
------------+-------------
42          |   427
427         |   4270
2 to 2      |   2 to 29
23 42 76-   |   23 42 76-5
-           |   -0

code-golf

— Fors
स्रोत

मैं पीट प्रविष्टियों को जीत का दावा करते हुए देखने के लिए उत्सुक हूं।

— अल्छमिस्ट

3

पायथ, 49 वर्ण

+z`u@sm>+0jCdT_6"Ľ򒉲򭉟񶯆𐱩򐞆󰆂򕟐򑽌򵋏󇋽򯴆󚙈𱑂񞑼쵥񪨶"+*TGvH:z"\D"k0

इसमें शामिल है कि भगवान जानता है कि कौन से वर्ण हैं, इसलिए यहां उपरोक्त पायथन 3 प्रोग्राम आपके मशीन पर सटीक रूप से उत्पन्न होता है:

N = 317598642709215486342068713591750983426612304597836742095815869720134894536201794386172052581436790
M = 1000000
l = []
while N:
    l.insert(0, N % M)
    N //= M

n = "".join(chr(c) for c in l)

s = '+z`u@sm>+0jCdT_6"' + n + '"+*TGvH:z"\D"k0'

with open("golf.pyth", "wb") as f:
    f.write(s.encode("utf-8"))

print("Program length is {} characters.".format(len(s)))

स्पष्टीकरण:

+z`                                     Output the input followed by a
                                        stringified...
   u                         :z"\D"k0   Reduction starting with 0 of digits
                                        in input...
    @                  +*TGvH           Indexing ... by 10*prev + int(next).
     sm         "ZALGO"                 Sum all digits created by ... over the
                                        unicode garbage.
       >+0     6                        Prepend 0 if needed to...
          jCdT_                         Codepoint converted to sequence of
                                        digits.

— orlp
स्रोत

3

CJam, 54 वर्ण

q_o{A,s&},{~0"끼´慜䪝膞䝮芜㮜ꡞ靓渏縰蒆㣉倔쵶"2G#bAb+A/T==:T;}/T

वहाँ एक unprintable चरित्र है, तो आप नीचे permalink का उपयोग करना चाहते हो सकता है।

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

व्याख्या

अंतरिम अंक को ट्रैक किया जा रहा है T, जिसे CJam 0 से प्रारंभ करता है।

q_o                                  "Read STDIN, duplicate it and print it.";
   {A,s&},                           "Filter out all non-digit characters.";
          {                     }/   "For each digit character.";
           ~                         "Eval to get the digit itself.";
            0                        "Push a zero.";
             "..."2G#b               "Push that long string and interpret the character
                                      codes as the digits of a base-2^16 number.";
                      Ab+            "Get base-10 digits and prepend the 0.";
                         A/          "Split into rows of 10.";
                           T=        "Select row based on interim digit.";
                             =       "Select column based on current digit.";
                              :T;    "Store in T and discard.";
                                   T "Push the interim digit to be printed.";

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

3

पायथन 3, 149 141 138 अक्षर

import re
l=""
for c in"ĽᝢႮ⏿ዿၮ∉᜝Ꮺൢ៫ǋẜ᳼╭᛭ᰡඡᆸߡⓞ᠜ȍ῏᪆":l+="%04d"%ord(c)
def D(b):
 a="0"
 for i in re.sub("\D","",b):a=l[int(a+i)]
 return b+a

उदाहरण:

 Input | Output
-------+--------
    42 | 427
   427 | 4270
2 to 2 | 2 to 29
   123 | 1234
  1234 | 12340
     - | -0

कुल 11 पात्रों को निकालने में मदद करने के लिए @MegaTom और @Sieg को धन्यवाद

— एकध्रुवीय
स्रोत

2

10 * int (a) + int (i) int (a + i) है, है ना?

— मेगाटॉम

अच्छी बात! धन्यवाद, कि 5 चार्ट बचाता है।

— मोनोपोल

1

एक एकल कथन के बाद के बीच में एक नई पंक्ति की जरूरत नहीं है। (-3)

— २१

2

रूबी, 149 अक्षर

i="0";t="0#{'2uleblnnz0nbpv3kqkaufbjqebm57jdj6ubaba1mc2fyucqff69tbllrcvw393li'.to_i 36}";puts(gets.chomp.each_char{|c|i=(c=~/\d/?t[(i+c).to_i]:i)}+i)

Repl.it पर परीक्षण किया गया

— MegaTom
स्रोत

2

जे, 117 बाइट्स

केवल प्रिंट करने योग्य ascii शामिल है। (मेरे पास J और यूनिकोड के साथ एक कठिन समय था।) पंक्तियों के क्रमचय-सूचकांकों से संक्रमण तालिका उत्पन्न करता है।

3 :'y,":(((_4(87)&#:inv\40-~a.i.''(3/3+wGf*Dl:(zaW+Hhw*(1p+;~.,y>m-<MZ)JCs'')A.i.10){~<@,~)/|.0,(#~10>])(1":i.10)i.y'

उपयोग:

   damm=.3 :'y,":(((_4(87)&#:inv\40-~a.i.''(3/3+wGf*Dl:(zaW+Hhw*(1p+;~.,y>m-<MZ)JCs'')A.i.10){~<@,~)/|.0,(#~10>])(1":i.10)i.y'

   damm '23 42 76-'
23 42 76-5

   damm ''
0

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

— randomra
स्रोत

2

हास्केल, 131 अक्षर

import Data.Char
f n=n++(show$foldl(\x y->read[('0':(show.ord=<<"౧⚈ક×ዿၮ∉ɏᵕₖ᧔İɕSʢ凞㷽ᰡ衎텴䘗↩倭῏᪆"))!!(x*10+y)])0[read[i]|i<-n,isDigit i])

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

> mapM_ (putStrLn.f) ["42", "427", "2 to 2", "23 42 76-", "-"]
427
4270
2 to 29
23 42 76-5
-0

— nimi
स्रोत

0

k, 36 वर्ण

/ declare quasi-group  
M:"H"$'"0317598642709215486342068713591750983426612304597836742095815869720134894536201794386172052581436790"

/ declare function
  f:{x,$0{M y+10*x}/"H"$'x@&x in .Q.n}

/ get length of function
  #$f
36

/ execute function against test input
  .q.show f@'{x!x}("42";"427";"2 to 2";"23 42 76-";,"-")
"42"       | "427"
"427"      | "4270"
"2 to 2"   | "2 to 29"
"23 42 76-"| "23 42 76-5"
,"-"       | "-0"

क्ष, 40 वर्ण (k के समतुल्य कार्यान्वयन)

 f:{x,string 0{M y+10*x}/"H"$'x inter .Q.n}

— user38879
स्रोत

1

मुझे कहना चाहिए कि मैं नियमों में एक संदिग्ध लूप-होल के उपयोग की प्रशंसा करता हूं, लेकिन मुझे वास्तव में क्वैसी-ग्रुप की घोषणा के समावेश को लागू करने के लिए नियमों को स्पष्ट करना चाहिए और वर्ण गणना में किसी भी प्रकार के सहायता समारोह की घोषणा करनी चाहिए। ।

— फोर्स

डैम एल्गोरिथ्म का उपयोग करके एक चेक अंक की गणना करें