यातायात की दिशा

Question

नियम

ISO3166-1-Alpha-2 देश कोड को देखते हुए आपका कार्य उस देश के लिए यातायात दिशा तय करना है:

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

ये सभी ऐसे देश हैं जहाँ यातायात बाएँ हाथ से किया जाता है:

['AI', 'AG', 'AU', 'BS', 'BD', 'BB', 'BM', 'BT', 'BW', 'VG', 'BN', 'KY', 'CX', 'CC', 'CK', 'CY', 'DM', 'FK', 'FJ', 'GD', 'GG', 'GY', 'HK', 'IN', 'ID', 'IE', 'IM', 'JM', 'JP', 'JE', 'KE', 'KI', 'LS', 'MO', 'MW', 'MY', 'MV', 'MT', 'MU', 'MS', 'MZ', 'NA', 'NR', 'NP', 'NZ', 'NU', 'NF', 'PK', 'PG', 'PN', 'SH', 'KN', 'LC', 'VC', 'WS', 'SC', 'SG', 'SB', 'SO', 'ZA', 'GS', 'LK', 'SR', 'SZ', 'TH', 'TL', 'TK', 'TO', 'TT', 'TC', 'TV', 'UG', 'GB', 'TZ', 'VI', 'ZM', 'ZW']

और यहां वे सभी देश हैं जहां ट्रैफिक राइट-हैंडेड है:

['AF', 'AX', 'AL', 'DZ', 'AS', 'AD', 'AO', 'AQ', 'AR', 'AM', 'AW', 'AT', 'AZ', 'BH', 'BY', 'BE', 'BZ', 'BJ', 'BO', 'BA', 'BV', 'BR', 'IO', 'BG', 'BF', 'BI', 'CV', 'KH', 'CM', 'CA', 'CF', 'TD', 'CL', 'CN', 'CO', 'KM', 'CG', 'CR', 'CI', 'HR', 'CU', 'CW', 'CZ', 'KP', 'CD', 'DK', 'DJ', 'DO', 'EC', 'EG', 'SV', 'GQ', 'ER', 'EE', 'ET', 'FO', 'FI', 'FR', 'GF', 'PF', 'TF', 'GA', 'GM', 'GE', 'DE', 'GH', 'GI', 'GR', 'GL', 'GP', 'GU', 'GT', 'GW', 'GN', 'HT', 'HM', 'VA', 'HN', 'HU', 'IS', 'IR', 'IQ', 'IL', 'IT', 'JO', 'KZ', 'KW', 'KG', 'LA', 'LV', 'LB', 'LR', 'LY', 'LI', 'LT', 'LU', 'MG', 'ML', 'MH', 'MQ', 'MR', 'YT', 'MX', 'FM', 'MC', 'MN', 'ME', 'MA', 'MM', 'NL', 'NC', 'NI', 'NG', 'NE', 'MP', 'NO', 'OM', 'PW', 'PA', 'PY', 'PE', 'PH', 'PL', 'PT', 'PR', 'QA', 'KR', 'MD', 'RE', 'RO', 'RU', 'RW', 'BL', 'MF', 'PM', 'SM', 'ST', 'SA', 'SN', 'RS', 'SL', 'BQ', 'SX', 'SK', 'SI', 'SS', 'ES', 'PS', 'SD', 'SJ', 'SE', 'CH', 'SY', 'TW', 'TJ', 'MK', 'TG', 'TN', 'TR', 'TM', 'UA', 'AE', 'UM', 'US', 'UY', 'UZ', 'VU', 'VE', 'VN', 'WF', 'EH', 'YE']

---

संपूर्णता के लिए, यहां एक CSV फ़ाइल है जिसमें देश के नाम के साथ सभी मान शामिल हैं।

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

यह मानकर कि आपने Lबाएं हाथ के ट्रैफ़िक के लिए आउटपुट चुना है , यहाँ कुछ मान्य परीक्षण मामले हैं:

'PY' -> 'python'
'PN' -> 'L'
'CN' -> 33
'GY' -> 'L'

नोट: एक छोटा सा मौका है कि मैं एक देश से चूक गया या कि एक गलत वर्गीकरण है और मैं चश्मा नहीं बदलूंगा क्योंकि इससे उत्तर अमान्य हो सकते हैं। अगर मैंने गलती की है तो मैं ईमानदारी से माफी माँगता हूँ, कृपया अपराध न करें!

Comments

अगर देश कोड से मेल नहीं खाता है तो क्या कुछ भी आउटपुट करना ठीक है?

— स्टीववेस्टल

@SteveFest: मैं कहूंगा कि कुछ और के रूप में मायने रखता है , हाँ।

— ბიმო

क्या मैं लेफ्ट केस के लिए "लेफ्ट" आउटपुट कर सकता हूं और राइट केस में कुछ और?

— l4m2

मैं यहां एक 10-बाइट मैथेमेटिका समाधान खोजने की उम्मीद में आया था जो किसी तरह बनाया गया था। मैं बुरी तरह निराश हूं।

— सिल्वियो मायोलो

@SilvioMayolo CountryDataकिसी देश में पक्की और बिना पक्की सड़क और रेलमार्ग आदि की मात्रा दे सकता है लेकिन उसकी यातायात दिशा नहीं :(

— HyperNeutrino

Answer 1

पायथन 2 , 145 136 112 109 बाइट्स

'TTHSZWMSGSONPKNZMWVIDFKELSCYJPNFJMTVCXBNRBWSHKYAUGGYBTLCCKIMVGBSBBMZAINAGDMOBDIEJEMYMUNUPGSRLKTKTOTCTZ'.find

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

-1दाएं हाथ के ट्रैफ़िक के लिए आउटपुट । इस रेटिना स्क्रिप्ट के साथ स्ट्रिंग को ऑटोजेनर किया गया है । 9 बाइट्स कम लुकअप स्ट्रिंग के लिए पूरी तरह से अमानवीय के लिए धन्यवाद । मैं AdmBorkBork सुझाव के माध्यम से 24 बाइट्स अधिक प्राप्त करने में सक्षम था ।
पाइथन स्क्रिप्ट का उपयोग करके लुकअप स्ट्रिंग 3 बाइट्स को छोटा कर दिया।

Comments

चूँकि जैसी चीजें OTमौजूद नहीं हैं, क्या आप कुछ स्थानों से छुटकारा पा सकते हैं जैसे कि TO TCजाना जाता है TOTC?

— AdmBorkBork

@AdmBorkBork बहुत बहुत धन्यवाद, मुझे सभी स्थान मिल गए।

— २।

क्या आप स्ट्रिंग की व्याख्या कर सकते हैं?

— गिगाफ्लॉप

Answer 2

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

मेरी मदद करने के लिए @ Mr.Xcoder को धन्यवाद देने के लिए बहुत-बहुत धन्यवाद @JonathanAllan को 1 बाइट थैंक्स

0दाएं हाथ के लिए या 1बाएं हाथ के लिए रिटर्न ।

“ŒỴ¬Ʋ>r¤dị|®ædHẇ⁸ɗH^CŒ³ẇPḷgȤƲȥƓƑ®Ƭṅḅ4ṛḟṄ’ḃ⁴+\
Oḅ⁹×6%⁽£€%566e¢

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

कैसे?

हम प्रत्येक देश कोड को आधार-256 के रूप में दर्ज करके एक पूर्णांक N में परिवर्तित करते हैं और निम्नलिखित हैश फ़ंक्शन को लागू करते हैं, जो बाएं हाथ से दाएं हाथ के ट्रैफ़िक के लिए टकराव मुक्त है:

((N * 6) MOD 1513) MOD 566

यह बाएं हाथ के ट्रैफ़िक के लिए निम्न सूची की ओर जाता है:

[   8,  14,  27,  37,  52,  60,  62,  68,  71,  84,  85,  88, 103, 105, 114, 119, 135,
  166, 167, 180, 187, 190, 195, 196, 202, 207, 208, 211, 214, 225, 226, 229, 232, 255,
  256, 262, 285, 301, 302, 303, 304, 309, 322, 325, 327, 337, 357, 369, 370, 381, 393,
  401, 408, 413, 420, 430, 453, 467, 473, 478, 492, 503, 509, 513, 516, 527, 528, 541,
  546, 547, 556, 562 ] (72 entries)

दो लगातार प्रविष्टियों के बीच औसत अंतर 8. के ​​करीब है। हम श्रेणी [1 ... 16] में वेतन वृद्धि के साथ सूची को संलग्न करते हैं। इसका मतलब यह है कि जब भी वेतन वृद्धि 16 से अधिक होती है, तो हमें अप्रयुक्त स्लॉट पर एक मध्यवर्ती मूल्य डालने की आवश्यकता होती है (हमें यह सुनिश्चित करना होगा कि यह दाहिने हाथ के ट्रैफिक से न टकराए)। लेकिन हैश फ़ंक्शन को इस तरह से चुना गया था कि हमें केवल कुछ पदों के लिए ऐसा करना होगा। यह देता है:

[  8,  6, 13, 10, 15,  8,  2,  6,  3, 13,  1,  3, 15,  2,  9,  5, 16, 15, 16,  1, 13,
   7,  3,  5,  1,  6,  5,  1,  3,  3, 11,  1,  3,  3, 16,  7,  1,  6, 16,  7, 16,  1,
   1,  1,  5, 13,  3,  2, 10, 16,  4, 12,  1, 11, 12,  8,  7,  5,  7, 10, 16,  7, 14,
   6,  5, 14, 11,  6,  4,  3, 11,  1, 13,  5,  1,  9,  6 ] (77 entries)

हम इस सूची को विशेषण आधार -16 से निम्न पूर्णांक में परिवर्तित करते हैं:

274705197430389746738026977757328941544772847257562272094076195694133371689429679543810871702

जो “ŒỴ¬Ʋ>r¤dị|®ædHẇ⁸ɗH^CŒ³ẇPḷgȤƲȥƓƑ®Ƭṅḅ4ṛḟṄ’जेली के बेस -250 एनकोडिंग में बन जाता है।

पहला लिंक इस पूर्णांक से मूल सूची को फिर से बनाता है और दूसरा परीक्षण करता है कि इसमें इनपुट का हैश है या नहीं।

“ŒỴ¬Ʋ>r¤dị|®ædHẇ⁸ɗH^CŒ³ẇPḷgȤƲȥƓƑ®Ƭṅḅ4ṛḟṄ’ḃ⁴+\      - 1st link: takes no input
“ŒỴ¬Ʋ>r¤dị|®ædHẇ⁸ɗH^CŒ³ẇPḷgȤƲȥƓƑ®Ƭṅḅ4ṛḟṄ’          - our big integer
                                         ḃ⁴        - convert it to bijective base-16
                                           +\      - apply delta-decoding

Oḅ⁹×6%⁽£€%566e¢                  - 2nd link: takes the country code  -> e.g. 'GB'
O                                - get ASCII codes                   -> [71, 66]
 ḅ⁹                              - convert from base-256 to integer  -> 18242
   ×6                            - multiply by 6                     -> 109452
     %⁽£€                        - modulo 1513                       -> 516
         %566                    - modulo 566                        -> 516
             e                   - look for it in the decoded list,
              ¢                  - using the first link as a nilad   -> 1

Comments

एक बाइट को एक पूर्णांक से बायजेक्टिव बेस 16 में परिवर्तित करके सहेजें : “ŒỴ¬Ʋ>r¤dị|®ædHẇ⁸ɗH^CŒ³ẇPḷgȤƲȥƓƑ®Ƭṅḅ4ṛḟṄ’ḃ⁴(इस प्रकार वेतन वृद्धि से बचना) ... यह भी (एक बाइट नहीं बचा, लेकिन) ¢एक निलाद के रूप में अंतिम लिंक को कॉल करता है।

— जोनाथन एलन

@JonathanAllan अच्छा लगा! धन्यवाद।

— अरनुलद

Answer 3

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

"$args"-match'A[GIU]|B[BDMNSTW]|[CFHW][CJKSXY]|DM|G[BDGSY]|[IJ][DEMNP]|K[EINY]|L[CKS]|M[OS-WYZ]|N[AFP-Z]|P[GKN]|S[BCGHORZ]|T[CHKLOTVZ]|UG|V[CGI]|Z.'

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

Nave रेगेक्स पैटर्न का मिलान। Trueबाएं हाथ के लिए और Falseदाएं हाथ के लिए आउटपुट ।

13 बाइट्स सहेजे गए हैं जो कि रेक्स को गोल करने वाले व्यापारी का धन्यवाद करते हैं।

Comments

आप पहले अक्षर C, F, H और W [CFHW][CJKSXY](-5), I और J में [IJ][DEMNP](-3), N को N[AFP-Z](-1), और Z को Z.(-4) में, कुल के लिए विकल्पों में शामिल कर सकते हैं । -13 बाइट्स। न्यू रेगेक्स =A[GIU]|B[BDMNSTW]|[CFHW][CJKSXY]|DM|G[BDGSY]|[IJ][DEMNP]|K[EINY]|L[CKS]|M[OS-WYZ]|N[AFP-Z]|P[GKN]|S[BCGHORZ]|T[CHKLOTVZ]|UG|V[CGI]|Z.

— व्यापारी

@ रेक्सटर गोल्फिंग के लिए धन्यवाद!

— AdmBorkBork 13

Answer 4

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

-5 बाइट्स ओव्स के लिए धन्यवाद।

import Data.List
(`isInfixOf`"MSOBTVGBSBBMZAINAGDMOAUGGYBDBWSHKYBNRJPNFJMVCKIMTLCCXLSCYFKEVIDIEJELSGSOLKNZMWMYMUPKNPGSRNUTKTOTCTZSZWTTH")

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

हाथ से मूल स्ट्रिंग उत्पन्न की।

Comments

लुकअप स्ट्रिंग 3 बाइट्स फिर से छोटी हो गई:TTHSZWMSGSONPKNZMWVIDFKELSCYJPNFJMTVCXBNRBWSHKYAUGGYBTLCCKIMVGBSBBMZAINAGDMOBDIEJEMYMUNUPGSRLKTKTOTCTZ

— ovs

एक अन्य विकल्प -3: SZAINAGGDMOAUGBBSCCKIMWSHKYLSBMVGSGYBDBTHBWBNRMZMTLCXSRTVCYPNFKNPKEFJMYVIDIEJPGJEMUNZWMSONULKTKTOTTCTZ- इसे ऑनलाइन आज़माएं!

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

Answer 5

05AB1E , 82 68 बाइट्स

बाएं-ट्रैफ़िक के लिए आउटपुट 1 और राइट-ट्रैफ़िक के लिए 0 है।

.•6uγ)₅₄вwÔívtÎĆ–≠5βI·{!ÅÇΔ›íÕ(1.€ò“Ѧ_£äß₂Ë‹ûÚм2±rrÇQ=ÅÔζ)B†š¢¡ε•så

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

पूरी तरह से अमानवीय और अंडाणुओं द्वारा सुधार की गई स्ट्रिंग का उपयोग करता है

Answer 6

05AB1E , 76 बाइट्स

.•B6L>õKвΩ~#ëΓnĀÿι–öß/çĸ’Û´äηÅÚ‚zĨe÷ö#YʒƒʒjªêKΩoúö‰Öe¡₄Æ∞¤iY¥•#vySANèì})åZ

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

---

.•B6L>õKвΩ~#ëΓnĀÿι–öß/çĸ’Û´äηÅÚ‚zĨe÷ö#YʒƒʒjªêKΩoúö‰Öe¡₄Æ∞¤iY¥•

निम्नलिखित स्ट्रिंग आउटपुट:

GIU BDMNSTW CKXY M  JK BDGSY K DEMN EMP EINY CKS OSTUVWYZA FPRUZ  GKN   BCGHORZ CHKLOTVZ G CGI S   AMW

अगर मैं रिक्त स्थान पर विभाजित करता हूं, और प्रत्येक स्ट्रिंग में वर्णमाला को इंटरलेव करता हूं, तो इसका परिणाम सभी राज्यों में होता है जो बाईं ओर ड्राइव करते हैं।

---

बाएं के लिए 1, दाएं के लिए 0; Emigna बेहतर है, लेकिन यह काफी अलग लगा :) पोस्ट करने के लिए।

Answer 7

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

ẇ“h¦¤$>Xø3¬I_°Ḷd⁺+ç*p¢7"FU]#x⁹ĿAxḷŻbCȦ]$ḣẒẓST¬ȥ¬ṆṠ®æ÷©#ḄS#MĠỤ4ɱ5’ṃØA¤

वर्णों की एक सूची लेने और वापस जाने पर 1( 0यदि दाएं) एक मुद्रीकृत लिंक ।

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

कैसे?

विधि का उपयोग पूरी तरह से अमानवीय / अंडाकार के रूप में किया जाता है ।

ẇ“ ... ’ṃØA¤ - Link: list of characters
           ¤ - nilad followed by link(s) as a nilad:
 “ ... ’     -   base 250 number = 19752831477605543488091668410027486265612829758468833715947215534967455540194888181580207621675010690833131726534873382634884974263558670694315853304
         ØA  -   list of characters = "ABCDEFGHIJKLMNPQRSUVWXZ"
        ṃ    -   base decompress = "MSOBTVGBSBBNZAINAGDMOAUGGYBDBWSHKYBNRJPNFJMVCKIMTLCCXLSCYFKEVIDIEJELSGSOLKOZMWMYMUPKNPGSRNUTKTOTCUZTZWTTH"
ẇ            - is a sublist of?

---

इसके अलावा, मैंने स्वतंत्र रूप से 72 बाइट्स में क्या किया :

“¦w/ḳœBẒḂṡẏ,©ḷĿdẎq⁸4ṙ^|ṂỌʋ:vkɱF#ẊṠµd¤w,ḋhn|ȯ24ɦm|×ỵ’ṃ©ØAO0;I<0œṗ®ṭ€"ØAẎċ

इसके अलावा, पात्रों की एक सूची लेने और वापस जाने पर 1( 0यदि दाएं) एक राक्षसी लिंक है ।

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

कैसे?

“ ... ’ṃ©ØAO0;I<0œṗ®ṭ€"ØAẎċ - Link: list of characters
“ ... ’                     - base 250 number = 20449742094039418439524274048234013619715377161457577389098927787850535557806494274193349238496252074719534810320317229
         ØA                 - list of characters = "ABCDEFGHIJKLMNPQRSUVWXZ"
       ṃ                    - base decompress = "GIUBDMNSTWCKXYMKJKBDGSYKDEMNEMPEINYCKSOSTUVXZZAFPRVZHGKNDCBCGHOSZCHKLOTWZGCGIASCBAMW"
        ©                   - copy to register
           O                - cast to ordinals = [71,73,85,66,68,77,78,83,84,87,67,75,88,89,77,75,74,75,66,68,71,83,89,75,68,69,77,78,69,77,80,69,73,78,89,67,75,83,79,83,84,85,86,88,90,90,65,70,80,82,86,90,72,71,75,78,68,67,66,67,71,72,79,83,90,67,72,75,76,79,84,87,90,71,67,71,73,65,83,67,66,65,77,87]
            0               - literal zero
             ;              - concatenate = [0,71,73,85,66,68,77,78,83,84,87,67,75,88,89,77,75,74,75,66,68,71,83,89,75,68,69,77,78,69,77,80,69,73,78,89,67,75,83,79,83,84,85,86,88,90,90,65,70,80,82,86,90,72,71,75,78,68,67,66,67,71,72,79,83,90,67,72,75,76,79,84,87,90,71,67,71,73,65,83,67,66,65,77,87]
              I             - incremental differences = [71,2,12,-19,2,9,1,5,1,3,-20,8,13,1,-12,-2,-1,1,-9,2,3,12,6,-14,-7,1,8,1,-9,8,3,-11,4,5,11,-22,8,8,-4,4,1,1,1,2,2,0,-25,5,10,2,4,4,-18,-1,4,3,-10,-1,-1,1,4,1,7,4,7,-23,5,3,1,3,5,3,3,-19,-4,4,2,-8,18,-16,-1,-1,12,10]
                0           - literal zero
               <            - less than (vectorises) = [0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,1,0,1,0,0,0,0,1,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,1,0,0,1,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,1,0,1,1,1,0,0]
                   ®        - recall from register = "GIUBDMNSTWCKXYMKJKBDGSYKDEMNEMPEINYCKSOSTUVXZZAFPRVZHGKNDCBCGHOSZCHKLOTWZGCGIASCBAMW"
                 œṗ         - partition at truthy indexes = ["GIU","BDMNSTW","CKXY","M","K","JK","BDGSY","K","DEMN","EMP","EINY","CKS","OSTUVXZZ","AFPRVZ","H","GKN","D","C","BCGHOSZ","CHKLOTWZ","G","CGI","AS","C","B","AMW"]
                       ØA   - list of characters = "ABCDEFGHIJKLMNPQRSUVWXZ"
                      "     - zip with:
                    ṭ€      -   tack for €ach = [["AG","AI","AU"],["BB","BD","BM","BN","BS","BT","BW"],["CC","CK","CX","CY"],["DM"],["EK"],["FJ","FK"],["GB","GD","GG","GS","GY"],["HK"],["ID","IE","IM","IN"],["JE","JM","JP"],["KE","KI","KN","KY"],["LC","LK","LS"],["MO","MS","MT","MU","MV","MX","MZ","MZ"],["NA","NF","NP","NR","NV","NZ"],["OH"],["PG","PK","PN"],["QD"],["RC"],["SB","SC","SG","SH","SO","SS","SZ"],["TC","TH","TK","TL","TO","TT","TW","TZ"],["UG"],["VC","VG","VI"],["WA","WS"],["XC"],["YB"],["ZA","ZM","ZW"]]
                         Ẏ  - tighten = ["AG","AI","AU","BB","BD","BM","BN","BS","BT","BW","CC","CK","CX","CY","DM","EK","FJ","FK","GB","GD","GG","GS","GY","HK","ID","IE","IM","IN","JE","JM","JP","KE","KI","KN","KY","LC","LK","LS","MO","MS","MT","MU","MV","MX","MZ","MZ","NA","NF","NP","NR","NV","NZ","OH","PG","PK","PN","QD","RC","SB","SC","SG","SH","SO","SS","SZ","TC","TH","TK","TL","TO","TT","TW","TZ","UG","VC","VG","VI","WA","WS","XC","YB","ZA","ZM","ZW"]
                            - ...this is the left list plus EK, OH, QC, RC, WA, XC, and YB
                            -    (which are not in the right list)
                          ċ - count

Answer 8

Befunge, 155 152 147 146 बाइट्स

~48*%10p~20pv
\"`"`"A"+61p>:2g:48*%10g-!20g61g-!#@*#,_\1+:"O"#@`#._
NzBSgCLVStBGiIJknAVGPSuStAKvfCFHPLttBDIJzBIPkMStJn{NsBLMWgBMtAMnMtBMzcKCGmMNSt

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

80दाएं हाथ के देश के लिए आउटपुट , और कुछ भी बाएं हाथ के देश को दर्शाता है।

व्याख्या

कोड की निचली पंक्ति में सभी बाएं हाथ के देशों का प्रतिनिधित्व है। यह देश के कोड के पहले पात्रों की सूची है, जो उनके दूसरे चरित्र द्वारा समूहीकृत है। प्रत्येक समूह के अंत को समूह में अंतिम वर्ण को कम करके चिह्नित किया जाता है।

इसलिए उदाहरण के लिए पहला समूह Nz, प्रतिनिधित्व करता है NAऔर ZA। दूसरे समूह, BSgका प्रतिनिधित्व करता है BB, SBऔर GB। वर्णमाला के प्रत्येक अक्षर के लिए एक समूह है, पत्र को छोड़कर Q(कोई बाएं हाथ के देश कोड समाप्त नहीं होते हैं Q)। उस खाली समूह को चरित्र द्वारा दर्शाया गया है {, क्योंकि यह स्पष्ट रूप से किसी भी मान्य देश कोड से मेल नहीं खाएगा।

यह निर्धारित करने के लिए कि क्या दिया गया देश कोड इन प्रविष्टियों में से एक से मेल खाता है, हम सूची की जाँच के माध्यम से पुनरावृत्ति करते हैं कि क्या सूची में कोई भी चरित्र हमारे इनपुट के पहले चरित्र से मेल खाता है (मामले के लिए खाता 32), और यह भी कि संबंधित समूह , इनपुट के दूसरे वर्ण से मेल खाता है। समूह चरित्र के रूप में शुरू होता है A, और हर बार जब हम सूची में एक लोअरकेस अक्षर का सामना करते हैं तो वृद्धि होती है।

जब हम एक मिलान पाते हैं, तो हम स्टैक पर अंतिम वर्ण मान आउटपुट करते हैं (जो देश कोड का पहला वर्ण होगा - संभवतः स्टैक)। अन्यथा हम पूरी सूची के माध्यम से पुनरावृत्ति होने पर बाहर निकलेंगे, इस स्थिति में हम स्टैक पर अंतिम संख्या आउटपुट करेंगे, जो हमेशा 80 है।

Answer 9

विंडोज बैच, 289 279 199 193 181 130 118 बाइट्स

@echo TTHSZWMSGSONPKNZMWVIDFKELSCYJPNFJMTVCXBNRBWSHKYAUGGYBTLCCKIMVGBSBBMZAINAGDMOBDIEJEMYMUNUPGSRLKTKTOTCTZ|find "%1"

बाएं हाथ के ट्रैफ़िक के लिए ओव्स स्ट्रिंग को आउटपुट करता है, इसके अलावा कुछ भी आउटपुट नहीं करता है।

नोट: मैंने देखा कि यदि इनपुट में ऊपर दी गई सूची में कोई देश कोड है, तो यह अभी भी एल उत्पादन करेगा, हालांकि, यह चुनौती नियम का उल्लंघन नहीं करता है क्योंकि ओपी ने केवल देश कोड का उल्लेख किया है।

---

स्पष्टीकरण:

@echo TTHSZ...OTCTZ            :: List all country code.(compressed by ovs)
                   |           :: Pipe the result to the find command.

                    find "%1"  :: Find the first argument in the country code list,
                               :: and output the ovs string if found.

                               :: By default, FIND returns the piped string when
                               :: a match is found.

Answer 10

सी (जीसीसी) , 181 169 165 बाइट्स

f(x){x=strstr("AIAUBSBDBBMBTBWVGBNKYCXCCKCYDMFKFJGDGGYHKINIDIEIMJMJPJEKELSMOMWMYMVMTMUMZNANRNPNZNUNFPKPGPNSHKNLCVCWSSCSGSOZAGSLKSRSZTHTLTKTOTTCTVUGTZVIZMZW",x)?:82;}

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

Comments

क्या आप 82बाइट को बचाने के बजाय एकल अंक का उपयोग कर सकते हैं ? 9, उदाहरण के लिए, एक टैब चरित्र का उत्पादन होगा।

— झबरा

Answer 11

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

lambda l:l[1]in'GIU,BDMNSTW,CKXY,M,,JK,BDGSY,K,DEMN,EMP,EINY,CKS,OSTUVWYZ,AFPRUZ,,GKN,,,BCGHORZ,CHKLOTVZ,G,CGI,S,,,AMW'.split(',')[ord(l[0])-65]

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

Trueबाईं ओर के लिए प्रिंट , Falseदाईं ओर के लिए।

Answer 12

रेटिना , 150 117 बाइट्स

$
MSOBTVGBSBBMZAINAGDMOAUGGYBDBWSHKYBNRJPNFJMVCKIMTLCCXLSCYFKEVIDIEJELSGSOLKNZMWMYMUPKNPGSRNUTKTOTCTZSZWTTH
^(..).*\1

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

Answer 13

एक्सेल VBA, 118 बाइट्स

अनाम VBE तत्काल विंडो फ़ंक्शन जो सेल [A1]और आउटपुट से इनपुट लेता है 0यदि देश दाएं हाथ है

?InStr(1,"TTHSZWMSGSONPKNZMWVIDFKELSCYJPNFJMTVCXBNRBWSHKYAUGGYBTLCCKIMVGBSBBMZAINAGDMOBDIEJEMYMUNUPGSRLKTKTOTCTZ",[A1])

ovs 'स्ट्रिंग का उपयोग करता है

Answer 14

जाप, 126 100 97 बाइट्स

पूरी तरह से अमानवीय अंडा के लुकिंग स्ट्रिंग का उपयोग करता है । falseRHD या trueअन्यथा के लिए लोअरकेस और आउटपुट में इनपुट लेता है ।

`tszwmsgspknzmwvidfkelscyjpnfjmtvcxbnrbw¢kyauggybtlc×Svgbsbbmzaagd¶b¹ejemymunupgsrlktktctz`øU

कोशिश करो

बैकटिक्स के बीच सब कुछ लुकअप स्ट्रिंग को छोटा और संकुचित और øजांचता है कि इसमें इनपुट है या नहीं U।

Comments

ovs का तार अब बहुत छोटा है :-)

— ETHproductions

Answer 15

पायथ , 60 57 55 50 47 46 44 बाइट्स

00000000: 736d 406a 4322 579f 235e 804c c3eb 6f49  sm@jC"W.#^.L..oI
00000010: aee5 1f3d be3d 4e13 f326 1934 a181 a210  ...=.=N..&.4....
00000020: 7158 3f94 2232 2f43 5164 5336            qX?."2/CQdS6

ऑनलाइन चलाएं

इनपुट को एक बड़े पैमाने पर उद्धृत स्ट्रिंग ( 'AI') के रूप में लेता है । 3बाएँ और गैर के लिए रिटर्न3 लिए सही के लिए।

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

sm@jC"…"2/CQdS6
 m           S6   map for d in [1, …, 6]:
     "…"            string literal
    C               convert to integer from base 256
   j    2           digits in base 2
  @                 wrapping index at:
           Q          input string
          C           convert to integer from base 256
         /  d         integer division by d
s                 sum

जादू का तार पैदा करना

import binascii
import z3
n, k, c = 239, 6, 3
a = [z3.Bool('a{}'.format(i)) for i in range(n)]
def f(s0, s1):
    return z3.Sum([z3.If(a[(ord(s0) * 256 + ord(s1)) // j % n], 1, 0) for j in range(1, k + 1)]) == c
solver = z3.Solver()
solver.add(a[0])
for s0, s1 in ['AI', 'AG', 'AU', 'BS', 'BD', 'BB', 'BM', 'BT', 'BW', 'VG', 'BN', 'KY', 'CX', 'CC', 'CK', 'CY', 'DM', 'FK', 'FJ', 'GD', 'GG', 'GY', 'HK', 'IN', 'ID', 'IE', 'IM', 'JM', 'JP', 'JE', 'KE', 'KI', 'LS', 'MO', 'MW', 'MY', 'MV', 'MT', 'MU', 'MS', 'MZ', 'NA', 'NR', 'NP', 'NZ', 'NU', 'NF', 'PK', 'PG', 'PN', 'SH', 'KN', 'LC', 'VC', 'WS', 'SC', 'SG', 'SB', 'SO', 'ZA', 'GS', 'LK', 'SR', 'SZ', 'TH', 'TL', 'TK', 'TO', 'TT', 'TC', 'TV', 'UG', 'GB', 'TZ', 'VI', 'ZM', 'ZW']:
    solver.add(f(s0, s1))
for s0, s1 in ['AF', 'AX', 'AL', 'DZ', 'AS', 'AD', 'AO', 'AQ', 'AR', 'AM', 'AW', 'AT', 'AZ', 'BH', 'BY', 'BE', 'BZ', 'BJ', 'BO', 'BA', 'BV', 'BR', 'IO', 'BG', 'BF', 'BI', 'CV', 'KH', 'CM', 'CA', 'CF', 'TD', 'CL', 'CN', 'CO', 'KM', 'CG', 'CR', 'CI', 'HR', 'CU', 'CW', 'CZ', 'KP', 'CD', 'DK', 'DJ', 'DO', 'EC', 'EG', 'SV', 'GQ', 'ER', 'EE', 'ET', 'FO', 'FI', 'FR', 'GF', 'PF', 'TF', 'GA', 'GM', 'GE', 'DE', 'GH', 'GI', 'GR', 'GL', 'GP', 'GU', 'GT', 'GW', 'GN', 'HT', 'HM', 'VA', 'HN', 'HU', 'IS', 'IR', 'IQ', 'IL', 'IT', 'JO', 'KZ', 'KW', 'KG', 'LA', 'LV', 'LB', 'LR', 'LY', 'LI', 'LT', 'LU', 'MG', 'ML', 'MH', 'MQ', 'MR', 'YT', 'MX', 'FM', 'MC', 'MN', 'ME', 'MA', 'MM', 'NL', 'NC', 'NI', 'NG', 'NE', 'MP', 'NO', 'OM', 'PW', 'PA', 'PY', 'PE', 'PH', 'PL', 'PT', 'PR', 'QA', 'KR', 'MD', 'RE', 'RO', 'RU', 'RW', 'BL', 'MF', 'PM', 'SM', 'ST', 'SA', 'SN', 'RS', 'SL', 'BQ', 'SX', 'SK', 'SI', 'SS', 'ES', 'PS', 'SD', 'SJ', 'SE', 'CH', 'SY', 'TW', 'TJ', 'MK', 'TG', 'TN', 'TR', 'TM', 'UA', 'AE', 'UM', 'US', 'UY', 'UZ', 'VU', 'VE', 'VN', 'WF', 'EH', 'YE']:
    solver.add(z3.Not(f(s0, s1)))
res = solver.check()
print(res)
if res == z3.sat:
    m = solver.model()
    print('n={} k={} c={} a={!r}'.format(n, k, c, binascii.unhexlify('{:0{}x}'.format(
        int(''.join('01'[z3.is_true(m[x])] for x in a), 2), n // 8 * 2))))

Answer 16

सेड, १४ + १ 145 + 1 143 + 1 142 + 1 बाइट्स

के लिए एक अतिरिक्त बाइट -rध्वज के (पोसिक्स विस्तारित रेगेक्स)।

बाएं हाथ के ट्रैफ़िक के लिए खाली स्ट्रिंग आउटपुट, दाएं हाथ के ट्रैफ़िक के लिए मूल देश कोड।

s/A[GIU]|B[BDMNSTW]|C[CXY]|DM|FJ|G[BDGSY]|I[DEMN]|J[^O]|K[EINY]|L[CS]|M[OS-WYZ]|N[AFP-Z]|P[GN]|S[BCGHORZ]|T[CHLOTVZ]|UG|V[CGI]|WS|Z.|[^DMS]K//

उदाहरण:

$ echo -e 'PY\nPN\nCN\nGY' | sed -re 's/A[GIU]|B[BDMNSTW]|C[CXY]|DM|FJ|G[BDGSY]|I[DEMN]|J[^O]|K[EINY]|L[CS]|M[OS-WYZ]|N[AFP-Z]|P[GN]|S[BCGHORZ]|T[CHLOTVZ]|UG|V[CGI]|WS|Z.|[^DMS]K//'
PY

CN

$

समझाया गया इतिहास संपादित करें:

148 s/A[GIU]|B[BDMNSTW]|C[CKXY]|DM|F[JK]|G[BDGSY]|HK|I[DEMN]|J[EMP]|K[EINY]|L[CKS]|M[OSTUVWYZ]|N[AFPRUZ]|P[GKN]|S[BCGHORZ]|T[CHKLOTVZ]|UG|V[CGI]|WS|Z.//
    naïve regexp; the only optimization here is 'Z.'
145 s/A[GIU]|B[BDMNSTW]|C[CKXY]|DM|F[JK]|G[BDGSY]|HK|I[DEMN]|J[EMP]|K[EINY]|L[CKS]|M[OS-WYZ]|N[AFP-Z]|P[GKN]|S[BCGHORZ]|T[CHKLOTVZ]|UG|V[CGI]|WS|Z.//
    M[OSTUVWYZ] → M[OS-WYZ]
    N[AFPRUZ] → N[AFP-Z]
    the replacements can match inexistent coutries, which is totally fine
143 s/A[GIU]|B[BDMNSTW]|C[CXY]|DM|FJ|G[BDGSY]|I[DEMN]|J[EMP]|K[EINY]|L[CS]|M[OS-WYZ]|N[AFP-Z]|P[GN]|S[BCGHORZ]|T[CHLOTVZ]|UG|V[CGI]|WS|Z.|[^DMS]K//
    |[^DMS]K (which also matches impossible country codes) allows these changes:
    C[CKXY] → C[CXY]
    F[JK] → FJ
    |HK → ∅
    L[CKS] → L[CS]
    P[GKN] → P[GN]
    T[CHKLOTVZ] → T[CHLOTVZ]
142 s/A[GIU]|B[BDMNSTW]|C[CXY]|DM|FJ|G[BDGSY]|I[DEMN]|J[^O]|K[EINY]|L[CS]|M[OS-WYZ]|N[AFP-Z]|P[GN]|S[BCGHORZ]|T[CHLOTVZ]|UG|V[CGI]|WS|Z.|[^DMS]K//
    J[EMP] → J[^O] (thanks @Neil)

sed, 158 + 1 155 + 1 153 + 1 152 + 1 बाइट्स, गैर-खाली उत्तर

पिछले एक का थोड़ा बदलाव। Lबाएं हाथ के ट्रैफ़िक के लिए रिटर्न ।

s/[GIU]|B[BDMNSTW]|C[CXY]|DM|FJ|G[BDGSY]|I[DEMN]|J[^O]|K[EINY]|L[CS]|M[OS-WYZ]|N[AFP-Z]|P[GN]|S[BCGHORZ]|T[CHLOTVZ]|UG|V[CGI]|WS|Z.|[^DMS]K/&L/;s/^..//

Comments

के J[^O]बजाय आप का उपयोग कर सकते हैं J[EMP]?

— नील

FYI करें मैंने दूसरे अक्षर से समूहीकरण करने की कोशिश की लेकिन सबसे अच्छा मैं 3 बाइट्स लंबा कर सकता था:[^L]B|[^EMN]C|GD|[I-K]E|[AGPSUV]G|[AKV]I|FJ|[^DMS]K|TL|JM|[KP]N|JP|SR|[BGLW]S|[BT]T|AU|TV|CX|[CGK]Y|M[OS-WYZ]|N[AFP-Z]|[BI][DMNW]|[ST][HOZ]|Z.

— नील

हुह, J[^O]वास्तव में एक बार छोटे रेगेक्स की मेरी सूची में था, मुझे आश्चर्य है कि मैंने इसे कैसे याद किया। इस पर ध्यान दिलाने के लिए धन्यवाद! दूसरे अक्षर द्वारा समूहीकरण करने के लिए: के द्वारा समूहीकरण के अलावा आप बस उपयोग कर सकते हैं |[AGPSUV]Gया |[BGLW]Sलेकिन यह कुल स्कोर को बिल्कुल नहीं बदलेगा।

— थ्रिलर

Answer 17

एपीएल (डायलॉग) , 108 बाइट्स

1∊⍷∘'TTHSZWMSGSONPKNZMWVIDFKELSCYJPNFJMTVCXBNRBWSHKYAUGGYBTLCCKIMVGBSBBMZAINAGDMOBDIEJEMYMUNUPGSRLKTKTOTCTZ'

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

Ovs द्वारा लुकअप स्ट्रिंग का उपयोग करना।

बाएँ हाथ का ट्रैफ़िक = 1।
दाहिने हाथ का ट्रैफ़िक = 0।

Answer 18

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

2 बाइट @Craig Ayre के लिए धन्यवाद सहेजा गया

s=>"SZAINAGGDMOAUGBBSCCKIMWSHKYLSBMVGSGYBDBTHBWBNRMZMTLCXSRTVCYPNFKNPKEFJMYVIDIEJPGJEMUNZWMSONULKTKTOTTCTZ".match(s)

nullदाएं हाथ के ट्रैफ़िक के लिए रिटर्न

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

f=s=>"SZAINAGGDMOAUGBBSCCKIMWSHKYLSBMVGSGYBDBTHBWBNRMZMTLCXSRTVCYPNFKNPKEFJMYVIDIEJPGJEMUNZWMSONULKTKTOTTCTZ".match(s)

console.log("AI,AG,AU,BS,BD,BB,BM,BT,BW,VG,BN,KY,CX,CC,CK,CY,DM,FK,FJ,GD,GG,GY,HK,IN,ID,IE,IM,JM,JP,JE,KE,KI,LS,MO,MW,MY,MV,MT,MU,MS,MZ,NA,NR,NP,NZ,NU,NF,PK,PG,PN,SH,KN,LC,VC,WS,SC,SG,SB,SO,ZA,GS,LK,SR,SZ,TH,TL,TK,TO,TT,TC,TV,UG,GB,TZ,VI,ZM,ZW".split`,`.every(s=>f(s)!=null))
console.log("AF,AX,AL,DZ,AS,AD,AO,AQ,AR,AM,AW,AT,AZ,BH,BY,BE,BZ,BJ,BO,BA,BV,BR,IO,BG,BF,BI,CV,KH,CM,CA,CF,TD,CL,CN,CO,KM,CG,CR,CI,HR,CU,CW,CZ,KP,CD,DK,DJ,DO,EC,EG,SV,GQ,ER,EE,ET,FO,FI,FR,GF,PF,TF,GA,GM,GE,DE,GH,GI,GR,GL,GP,GU,GT,GW,GN,HT,HM,VA,HN,HU,IS,IR,IQ,IL,IT,JO,KZ,KW,KG,LA,LV,LB,LR,LY,LI,LT,LU,MG,ML,MH,MQ,MR,YT,MX,FM,MC,MN,ME,MA,MM,NL,NC,NI,NG,NE,MP,NO,OM,PW,PA,PY,PE,PH,PL,PT,PR,QA,KR,MD,RE,RO,RU,RW,BL,MF,PM,SM,ST,SA,SN,RS,SL,BQ,SX,SK,SI,SS,ES,PS,SD,SJ,SE,CH,SY,TW,TJ,MK,TG,TN,TR,TM,UA,AE,UM,US,UY,UZ,VU,VE,VN,WF,EH,YE".split`,`.every(s=>f(s)==null))

Comments

क्या आप उपयोग कर सकते हैं String.prototype.match()और दायें हाथ के ट्रैफ़िक को निरूपित कर सकते हैं null? 2 बाइट्स बचाएगी

— क्रेग आयरे

Answer 19

विम, 117 109 108 कीस्ट्रोक्स

oSZAINAGGDMOAUGBBSCCKIMWSHKYLSBMVGSGYBDBTHBWBNRMZMTLCXSRTVCYPNFKNPKEFJMYVIDIEJPGJEMUNZWMSONULKTKTOTTCTZ␛kg*D

इसे ऑनलाइन आज़माएं! ( SEदेश कोड के साथ हेडर में बदलें )

␛भागने की कुंजी है। कार्यक्रम दाहिने हाथ के ट्रैफ़िक के लिए निम्न पाठ प्रिंट करता है:

SZAINAGGDMOAUGBBSCCKIMWSHKYLSBMVGSGYBDBTHBWBNRMZMTLCXSRTVCYPNFKNPKEFJMYVIDIEJPGJEMUNZWMSONULKTKTOTTCTZ

व्याख्या

oSZAINA...OTTCTZ␛ Input the lookup-string on a new line
kg*D              Delete the everything after the last occurence of the country code
                   on the same line

Comments

मैं सराहना करता हूं कि आप मेरे पसंदीदा पाठ संपादक में जवाब दे रहे हैं, सही के लिए एक मूल्य चुनने का चतुर उपयोग !

— ბიმო

Answer 20

मेरी-बेसिक , 162 बाइट्स

अनाम फ़ंक्शन जो इनपुट को एक अनट्रैप्ड स्ट्रिंग (जो कि कोष्ठक के बिना) के रूप में लेता है और कंसोल को आउटपुट करता है

Input"",x$,
For y=0 To 100
z=z+(Mid("TTHSZWMSGSONPKNZMWVIDFKELSCYJPNFJMTVCXBNRBWSHKYAUGGYBTLCCKIMVGBSBBMZAINAGDMOBDIEJEMYMUNUPGSRLKTKTOTCTZ",y,2)=x$)
Next
Print z

0दाएं हाथ के लिए और 1बाएं हाथ के ट्रैफ़िक के लिए रिटर्न , इसे ऑनलाइन आज़माएं!

Answer 21

Yabasic , 127 बाइट्स

बेनामी फ़ंक्शन जो इनपुट को एक अपरिवर्तित स्ट्रिंग (नहीं "...") के रूप में लेता है और 0अगर देश दाएं हाथ में है और 1देश छोड़ दिया गया है तो आउटपुट ।

Input""A$
?InStr("TTHSZWMSGSONPKNZMWVIDFKELSCYJPNFJMTVCXBNRBWSHKYAUGGYBTLCCKIMVGBSBBMZAINAGDMOBDIEJEMYMUNUPGSRLKTKTOTCTZ",A$)>0

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

Answer 22

सी (जीसीसी) , 115 107 बाइट्स

f(short*x){x=!wcschr(L"䥁䝁啁卂䑂䉂䵂呂坂䝖乂奋塃䍃䭃奃䵄䭆䩆䑇䝇奇䭈义䑉䕉䵉䵊偊䕊䕋䥋卌位坍奍噍呍啍卍婍䅎剎偎婎啎䙎䭐䝐乐䡓之䍌䍖南䍓䝓䉓体䅚升䭌剓婓䡔䱔䭔佔呔䍔噔䝕䉇婔䥖䵚坚",*x);}

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

रिटर्न 0अगर हाथ छोड़ दिया है। -4 @JonathanFrech को धन्यवाद

Comments

क्या आप short*पैरामीटर के रूप में लेने के लिए अपने कार्य को परिभाषित नहीं कर सकते हैं ?

— जोनाथन फ्रेच

Answer 23

के, 105 बाइट्स

K / Q भाषाओं के बारे में जानकारी के लिए code.kx.com देखें

उपयोग: देश-कोड (2-चार स्ट्रिंग, उदाहरण "XY") के बाद

in[;+\-48+5h$"62<729151368=1>a1A23<6<C181A83?45;488F411112115:235Q43r141738353135247F42Tl<:"]@26/:-65+5h$

जनरेट 1b(बाएं हाथ का ट्रैफ़िक) या 0b(बाएं हाथ का ट्रैफ़िक नहीं)

स्पष्टीकरण:

• 5h$"XX"2-चार स्ट्रिंग (देश-कोड) के प्रत्येक चार्ट के लिए एएससीआई कोड उत्पन्न करता है, उदाहरण 5h$"TB"84 66 उत्पन्न करता है

• -65+integerListसूची में प्रत्येक पूर्णांक में 65 को प्रतिस्थापित करें। उदाहरण -65+5h$"TB"19 1 उत्पन्न करता है

• 26/:integerList26-बेस में अंकों के रूप में उस सूची के बराबर पूर्णांक की गणना करता है। उदाहरण 26/:-65+5h$"TB"495 (पूर्णांक के रूप में देश-कोड) उत्पन्न करता है

• in[;listOfCountryCodesAsIntegers]@xबूलियन मान लौटाता है (1b = true, 0b = false)। सच है अगर x सूची में है

• +\-48+5h$"62<729151368=1>a1A23<6<C181A83?45;488F411112115:235Q43r141738353135247F42Tl<:" बाएं हाथ के ट्रैफ़िक वाले प्रत्येक देश कोड के लिए पूर्णांकों की सूची की गणना करता है

  • "62<729151368=1>a1A23<6<C181A83?45;488F411112115:235Q43r141738353135247F42Tl<:"'दूरी स्ट्रिंग' (आरोही क्रम में पूर्णांक-देश-कोड की प्रत्येक जोड़ी के बीच की दूरी, चार के रूप में संहिताबद्ध)। दूरी n को असिसी चार 48 एन के रूप में कोडित किया गया है

  • -48+5h$".." स्ट्रिंग में प्रत्येक चार की एससीआई मान की गणना करता है ".." और ओस्की-कोड के रूप में मूल दूरी को पुनर्प्राप्त करता है - 48. परिणाम दूरी की सूची है

  • +\integerList सूची से आइटम के आंशिक योग की गणना करता है -> पूर्ण पूर्णांक-देश-कोड के बीच की दूरी से।

टिप्पणियाँ।-

• रिटर्न 0bकिसी भी गैर-बाएँ हाथ वाले देश-कोड के लिए , जिसमें मान्य देश कोड शामिल नहीं हैं
• हम कोड को सुधारने वाले एक चार्ट को बचा सकते हैं, लेकिन कोड के अंदर देश-कोड "XX" लिखना आवश्यक है (मुझे नहीं पता कि क्या यह वैध है, लेकिन मुझे यकीन है कि यह सुरुचिपूर्ण नहीं है) in[26/:-65+5h$"XX";+\-48+5h$"..."]