स्पेनिश आईडी कार्ड नियंत्रण चरित्र कैलकुलेटर

20

यह एक बहुत ही सरल एल्गोरिथ्म है, मुझे यकीन है कि कई अलग-अलग भाषाओं में हल किया जा सकता है। स्पेन में आईडी कार्ड ( डीएनआई के रूप में जाना जाता है ) में 8 नंबर और एक नियंत्रण चरित्र होता है। नियंत्रण वर्ण की गणना निम्न एल्गोरिथम के साथ की जाती है: संख्या को 23 से विभाजित करें, शेष का संचालन करें और इसे इस तालिका के अनुसार वर्ण से प्रतिस्थापित करें: 

0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22  
T  R  W  A  G  M  Y  F  P  D  X  B  N  J  Z  S  Q  V  H  L  C  K  E

यदि DNI स्पेन में रहने वाले किसी विदेशी व्यक्ति का है, तो पहले अंक को बदल दिया जाता है X, Yया Zइसे NIE कहा जाता है । इस स्थिति में, नियंत्रण वर्ण की गणना करने से पहले निम्नलिखित विकल्प दिए गए हैं:

X Y Z
0 1 2

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

टिप्पणियाँ:

  • DNI हमेशा अपरकेस में लिखा जाता है, लेकिन आपके एल्गोरिथ्म में आप इनपुट और आउटपुट को ऊपरी या निचले हिस्से में चुन सकते हैं, बस सुसंगत रहें।
  • वास्तविक जीवन में, 2008 से पहले जारी किए गए कुछ एनआईई के पास 8 अंक हैं X, Yया Z, लेकिन इस खेल के उद्देश्यों के लिए, आप विचार कर सकते हैं कि उनके पास 7 अंक हैं क्योंकि वे आजकल हैं।
  • आप विचार कर सकते हैं कि इनपुट स्ट्रिंग में हमेशा 8 वर्ण होंगे, लेकिन यदि वे "8 अंक" प्रारूप में नहीं हैं और न ही "[XYZ] प्लस 7 अंक" प्रारूप, तो आपको एक त्रुटि (अपनी पसंद की) वापस करनी होगी या बस फेंकना होगा एक अपवाद।

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

00000010 -> X (HRM Juan Carlos I's DNI number)
01234567 -> L
98765432 -> M
69696969 -> T
42424242 -> Y
Z5555555 -> W (Z=2)
Y0000369 -> S (Y=1)
A1234567 -> <Error code or exception>
1231XX12 -> <Error code or exception>

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा की जीत के लिए सबसे छोटा कोड हो सकता है!

code-golf  kolmogorov-complexity 
— चार्ली
स्रोत
— चार्ली
2
क्या यह वास्तव में महत्वपूर्ण है कि कोड में अमान्य इनपुट पर एक विशिष्ट व्यवहार है? आमतौर पर यहां चुनौतियों को त्रुटि से निपटने के लिए चिंता करने की आवश्यकता नहीं है।
— ग्रेग मार्टिन
3
@GregMartin मेरी बात ठीक है, मैं सिर्फ यह चाहता था कि कोड त्रुटि इनपुट पर कुछ विशिष्ट व्यवहार दिखाए क्योंकि यह आमतौर पर आवश्यक नहीं होता है।
— चार्ली
"संख्या को 23 से विभाजित करें, बाकी ऑपरेशन करें", सही शब्द शेष है ; बाकी बहुत बोलचाल है।
— लोकोलिस्क जूल
2
@Locoluis स्पेनिश में हम रेस्टो कहते हैं , जिससे "रेस्ट" एक झूठा दोस्त बनता है । कम से कम मैंने एक गलत शब्द का उपयोग नहीं किया। :-) धन्यवाद!
— चार्ली

जवाबों:

11

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

lambda n:'TRWAGMYFPDXBNJZSQVHLCKE'[int([n,str(ord(n[0])%4)+n[1:]][n[0]in'XYZ'])%23]

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

-5 AlixEinsenhardt (99 से 94 तक) के लिए धन्यवाद । -1 के लिए धन्यवाद JonathanAllan ।

— श्री Xcoder
स्रोत
1
आप की जगह ले सकता str('XYZ'.index(n[0]))से str(ord(n[0])-88)और 5 बाइट्स बचाने
— एलिक्स Eisenhardt
1
@AixixEisenhardt उपरोक्त सुझाव ने मुझे तकनीक को एक लैम्ब्डा में बदलने के लिए प्रेरित किया, जिसने अंततः 10 बाइट्स बचाए।
— श्री एक्सकोडर
के -88साथ प्रतिस्थापित करके एक बाइट सहेजें %4।
— जोनाथन एलन
8

हास्केल , 107 93 92 बाइट्स

c(x:y)="TRWAGMYFPDXBNJZSQVHLCKE"!!mod(read(("X0Y1Z2"!x):y))23
(a:b:c)!x|x==a=b|2>1=c!x
_!x=x

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

— bartavelle
स्रोत
अमान्य इनपुट पर व्यवहार क्या है?
— चार्ली
वे कार्यक्रम को दुर्घटनाग्रस्त कर देंगे, मैंने एक उदाहरण में जोड़ा। (व्यवहार में यह एक अपवाद है कि कोई भी पकड़ता है)
— bartvelle
1
मैंने अपवाद को पकड़ने के साथ सबमिशन को अपडेट किया, ताकि सभी परीक्षण चलाए जा सकें।
— बर्तवेल्ले
5

पायथ, 35 34 बाइट्स

कोड में कुछ अनपेक्षित वर्ण हैं, इसलिए यहां एक प्रतिवर्ती xxdहेक्सडंप है।

00000000: 402e 5043 22fc eeff 1ffc adc7 e614 9451  @.PC"..........Q
00000010: 2247 2573 7358 637a 5d31 3e33 4755 3320  "G%ssXcz]1>3GU3
00000020: 3233                                     23

लोअरकेस वर्णों का उपयोग करता है ।

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

प्रिंट करने योग्य वर्शन

@.P305777935990456506899534929G%ssXcz]1>3GU3 23

व्याख्या

  • cz]1स्थिति 1 पर इनपुट को विभाजित करता है, उदाहरण के "y0000369"लिए ["y", "0000369"]।
  • >3Gवर्णमाला के अंतिम 3 वर्ण मिलते हैं "xyz"।
  • U3सीमा हो जाता है [0, 3 [ , [0, 1, 2]।
  • Xनक्शे xyzको [0, 1, 2]विभाजित सरणी में, उदाहरण के ["y", "0000369"]लिए [1, "0000369"]। यदि यह xyz7 वर्णों की पूंछ को छोड़ देता है, तो यह पहले वर्ण को बदल देता है , क्योंकि कोई भी 7 वर्ण स्ट्रिंग एक वर्ण के बराबर नहीं हो सकती है।
  • sरिक्त स्ट्रिंग, जैसे के साथ सरणी मिलती है [1, "0000369"]करने के लिए "10000369"।
  • sपूर्णांक को यह स्ट्रिंग, जैसे डाले "10000369"करने के लिए 10000369। यदि स्ट्रिंग में कोई भी अतिरिक्त गैर-अंक वर्ण छोड़ दिए जाते हैं, तो यह त्रुटि देता है।
  • %... 23मान modulo 23 हो जाता है, उदाहरण के 10000369लिए 15।
  • C"... "बाइनरी स्ट्रिंग को बेस 256 से पूर्णांक (लगभग 3.06 × 10 26 ) में कनवर्ट करता है ।
  • .P… Gउस सूचकांक के साथ वर्णमाला का क्रमचय मिलता है।
  • @ क्रमचय से सही चरित्र मिलता है।
— PurkkaKoodari
स्रोत
4

MATL , 62 59 बाइट्स

'RWAGMYFPDXBNJZSQVHLCKET'j'[\dXYZ]\d{7}'XXg'XYZ'I:47+XEU1))

वैध इनपुट नहीं होने की त्रुटि है A(I): index out of bounds(ऑक्टेव में चलने वाला कंपाइलर) या Index exceeds matrix dimensions(मैटलैब में चलने वाला कंपाइलर)।

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

व्याख्या

'RWAGMYFPDXBNJZSQVHLCKET' % Push this string (output letters circularly shifted by 1)
j                         % Unevaluated input
'[\dXYZ]\d{7}'            % Push this string (regexp pattern)
XX                        % Regexp. Returns cell arary with matching string, or empty
g                         % Convert to standard array. Will be empty if non-valid input
'XYZ'                     % Push this string
I:47+                     % Push [47 48 49] (ASCII codes of '012')
XE                        % Transliterate
U                         % Convert to number
1)                        % Get first entry. Gives an error if empty
)                         % Index (modular, 1-based) into initial string
                          % Implicitly display
— लुइस मेंडो
स्रोत
4

ईएस 6, 83 82 81 बाइट्स

i=>'TRWAGMYFPDXBNJZSQVHLCKE'[(/^[XYZ]/.test(i)?i.charCodeAt()%4+i.slice(1):i)%23]

कार्रवाई में!

केवल अपरकेस, अमान्य संख्याओं के लिए त्रुटि कोड है undefined।

एक बाइट ने जोनाथन एलन को धन्यवाद दिया।
एक और बाइट ने झबरा के लिए धन्यवाद बचाया।

— 2ndAttmt
स्रोत
शायद बाइट का उपयोग करने के %4बजाय बचाएं -88।
— जोनाथन एलन
आप ड्रॉप करने में सक्षम होना चाहिए 0से charCodeAt()भी।
— झबरा
3

जावा 8, 154 145 104 बाइट्स

s->{s[0]-=s[0]<88|s[0]>90?0:40;return"TRWAGMYFPDXBNJZSQVHLCKE".charA‌​t(new Integer(new String(s))%23);}

-9 बाइट्स @ ऑलीवरग्रेगायर के लिए धन्यवाद ।
-41 बाइट्स का धन्यवाद @ OliverGrégoire फिर से, इनपुट-चार-सरणी ( char[]) के रूप में लेने से ।

यदि इनपुट अमान्य है, यह या तो एक साथ विफल हो जाएगा java.lang.NumberFormatExceptionया java.lang.StringIndexOutOfBoundsException।

स्पष्टीकरण:

इसे यहाँ आज़माएँ। (अमान्य परीक्षण मामले ट्राइ-कैच से घिरे होते हैं इसलिए यह पहली त्रुटि पर नहीं रुकता है।)

s->{                      // Method with char[] parameter and char return-type
  s[0]-=s[0]<88|s[0]>90?  // If the first character is not XYZ:
    0                     //  Leave the first character as is
   :                      // Else:
    40;                   //  Subtract 40 to convert it to 012
  return"TRWAGMYFPDXBNJZSQVHLCKE".charAt(
                          //    Get the char from the String
    new Integer(          //    by converting the following String to an integer:
      new String(s)       //     by converting the char-array to a String
    )%23);                //    And take modulo-23 of that integer
}                         // End of method
— केविन क्रूज़सेन
स्रोत
1
आप |regex में की जरूरत नहीं है । इसके अलावा int t=s.charAt(0)-88और t<0?t+40:tआप अतिरिक्त एक बाइट।
— ओलिवियर ग्रेजायर 14
1
अंत में, आप एक त्रुटि कोड वापस कर सकते हैं। बस यह तय है कि यह है 'a'या '0'या किसी भी गैर अपरकेस अक्षर, और वापसी के बजाय t/0और करने के लिए बहुत कास्टिंग char। आप इस तरह से 7 बाइट्स बचाएंगे, मुझे लगता है। इस तरह से गोल्फ , आपको 145 बाइट्स मिलते हैं।
— ओलिवियर ग्राएगोयर
1
@ OlivierGrégoire धन्यवाद! मुझे लग रहा है कि .matchesइस रेगेक्स, btw के साथ सत्यापन के एक अलग तरीके का उपयोग करना अभी भी संभव है । लेकिन शायद मुझसे गलती हुई है।
— केविन क्रूज़सेन
1
नहीं, आप पूरी तरह से सही हैं! यह इस तरह से उल्लेखनीय है: s->{s[0]-=s[0]<88?0:40;return"TRWAGMYFPDXBNJZSQVHLCKE".charAt(new Integer(new String(s))%23);}केवल 94 बाइट्स के लिए ( sएक होने के साथ char[]): पी
— ओलिवियर ग्राएगोइरे
1
या यदि आप सत्यापन के बारे में पूरा होना चाहते हैं: s[0]<88&s[0]>908 और बाइट्स के लिए।
— ओलिवियर ग्राएगोयर
1

क्यू / केडीबी +, ६ k बाइट्स

समाधान:

{"TRWAGMYFPDXBNJZSQVHLCKE"mod["J"$$[3>a:"XYZ"?x 0;($)a;x 0],1_x;23]}

उदाहरण:

q){"TRWAGMYFPDXBNJZSQVHLCKE"mod["J"$$[3>a:"XYZ"?x 0;($)a;x 0],1_x;23]}"00000010"
"X"
q){"TRWAGMYFPDXBNJZSQVHLCKE"mod["J"$$[3>a:"XYZ"?x 0;($)a;x 0],1_x;23]}"01234567"
"L"
q){"TRWAGMYFPDXBNJZSQVHLCKE"mod["J"$$[3>a:"XYZ"?x 0;($)a;x 0],1_x;23]}"98765432"
"M"
q){"TRWAGMYFPDXBNJZSQVHLCKE"mod["J"$$[3>a:"XYZ"?x 0;($)a;x 0],1_x;23]}"69696969"
"T"
q){"TRWAGMYFPDXBNJZSQVHLCKE"mod["J"$$[3>a:"XYZ"?x 0;($)a;x 0],1_x;23]}"42424242"
"Y"
q){"TRWAGMYFPDXBNJZSQVHLCKE"mod["J"$$[3>a:"XYZ"?x 0;($)a;x 0],1_x;23]}"Z5555555"
"W"
q){"TRWAGMYFPDXBNJZSQVHLCKE"mod["J"$$[3>a:"XYZ"?x 0;($)a;x 0],1_x;23]}"Y0000369"
"S"
q){"TRWAGMYFPDXBNJZSQVHLCKE"mod["J"$$[3>a:"XYZ"?x 0;($)a;x 0],1_x;23]}"A1234567"
" "
q){"TRWAGMYFPDXBNJZSQVHLCKE"mod["J"$$[3>a:"XYZ"?x 0;($)a;x 0],1_x;23]}"1231XX12"
" "

स्पष्टीकरण:

यदि पहला चरित्र, x 0स्ट्रिंग में है, "XYZ"तो aहोगा 0, 1या 2। यदि पहला वर्ण स्ट्रिंग में नहीं है, तो aहोगा 3। अगरa 3 से कम है, तो हम पहले वर्ण को (a 0, 1या 2) के स्ट्रिंग के लिए स्विच करते हैं, अन्यथा हम पहले वर्ण के लिए स्विच करते हैं (इस प्रकार प्रभावी रूप से कुछ भी नहीं कर रहे हैं)। यह तार एक लंबे ( "J"$) के लिए डाला जाता है , जो तब modशेष राशि देने के लिए 23 के साथ होता है। इस शेष का उपयोग लुकअप टेबल में इंडेक्स करने के लिए किया जाता है।

{ "TRWAGMYFPDXBNJZSQVHLCKE" mod["J"$$[3>a:"XYZ"?x 0;string a;x 0],1_x;23] } / ungolfed solution
{                                                                         } / lambda function
                            mod[                                     ;23]   / performds mod 23 of the stuff in the gap
                                                                  1_x       / 1 drop input, drops the first character
                                                                 ,          / concatenation
                                    $[             ;        ;   ]           / if COND then TRUE else FALSE - $[COND;TRUE;FALSE]
                                        a:"XYZ"?x 0                         / "XYZ" find x[0], save result in a
                                      3>                                    / is this result smaller than 3
                                                    string a                / if so, then string a, e.g. 0 -> "0"
                                                             x 0            / if not, just return first character x[0]
                                "J"$                                        / cast to long
  "TRWAGMYFPDXBNJZSQVHLCKE"                                                 / the lookup table

टिप्पणियाँ:

" "त्रुटि परिदृश्यों में लौटा है, इसका कारण यह है कि कलाकार एक अशक्त रिटर्न देता है, और इंडेक्स नल में एक स्ट्रिंग में अनुक्रमण एक खाली चार है। मैं शुरुआत में 4 बाइट्स जोड़ सका ( "!"^) यह स्पष्ट करने के लिए कि एक त्रुटि हुई थी:

q){"!"^"TRWAGMYFPDXBNJZSQVHLCKE"("J"$$[3>a:"XYZ"?x 0;($)a;x 0],1_x)mod 23}"1231XX12"
"!"
— streetster
स्रोत
1

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

f=i=>{c=+i[0];a=3;while(a--){i[0]=="XYZ"[a]&&(c=a)}b=7;while(b--){c= +i[7-b]+c*10}return "TRWAGMYFPDXBNJZSQVHLCKE"[c%23]}

console.log([f("00000010"),f("01234567"),f("98765432"),f("69696969"),f("42424242"),f("Z5555555"),f("Y0000369"),f("A1234567"),f("1231XX12")])
स्निपेट का विस्तार करें

— Оввгений Новиков
स्रोत
1

जंग, 206 बाइट्स

मुझे नहीं लगता कि जंग गोल्फ कोडिंग के लिए अनुकूल है

let b=|s:&str|{s.chars().enumerate().map(|(i,c)|match i{0=>match c{'X'=>'0','Y'=>'1','Z'=>'2',_=>c},_=>c}).collect::<String>().parse::<usize>().ok().and_then(|x|"TRWAGMYFPDXBNJZSQVHLCKE".chars().nth(x%23))};
— dgel
स्रोत
1

05AB1E , 41 40 39 बाइट्स

ć…xyz2ÝJ‡ìDd_i.ǝ}23%.•Xk¦fΣT(:ˆ.Îðv5•sè

लोअरकेस में इनपुट लेता है (1 बाइट याय को बचाने के लिए )

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

यदि विकृत है तो इनपुट को STDERR में प्रिंट करता है

व्याख्या

ć…xyz2ÝJ‡ìDd_i.ǝ}23%.•Xk¦fΣT(:ˆ.Îðv5•sè
ć                                       # Get head of input and put the rest of the input under it on the stack
 …xyz                                   # Push xyz
     2ÝJ                                # Push 012
        ‡                               # Transliterate
         ì                              # Prepend to the rest of the input
          Dd_                           # Does the result contain something other than numbers?
             i.ǝ}                       # If so print input to STDERR
                 23%                    # Modulo 23
                    .•Xk¦fΣT(:ˆ.Îðv5•   # Pushes the character list
                                     sè # Get the char at the index of the modulo
— Datboi
स्रोत
0

डायलॉग एपीएल, 95 बाइट्स

{'TRWAGMYFPDXBNJZSQVHLCKE'[1+23|(10⊥¯1+'0123456789'⍳{(⍕{('XYZ'⍳⍵)<4:('XYZ'⍳⍵)-1⋄⍵} ⊃⍵),1↓⍵}⍵)]}

यह एक राक्षसी ऑपरेटर है जो एक चरित्र स्ट्रिंग को अपने ऑपरेंड के रूप में स्वीकार करता है और इसका परिणाम देता है।

FIXME यह अपने इनपुट की जाँच नहीं करता है। यह ठीक से गोल्फ नहीं है।

उपयोग:

    OP ← {'TRWAGMYFPDXBNJZSQVHLCKE'[1+23|(10⊥¯1+'0123456789'⍳{(⍕{('XYZ'⍳⍵)<4:('XYZ'⍳⍵)-1⋄⍵} ⊃⍵),1↓⍵}⍵)]}

      OP '01234567'
L

      OP '00000010'
X
— Locoluis
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.