सभी देश कोड प्रिंट करें


24

ISO 3166-1 वह मानक है जो सभी देश कोड को परिभाषित करता है। प्रसिद्ध दो-अक्षर कोड (यूएस, जीबी, जेपी, आदि) को अल्फा -2 कोड कहा जाता है।

दो अक्षरों के साथ, केवल 26 2 = 676 संभावित कोड हैं, जो अच्छी तरह से एक ग्रिड में व्यवस्थित हो सकते हैं। यह तालिका अवलोकन के रूप में उपयोगी हो सकती है, यह देखने के लिए कि कौन से कोड वास्तव में उपयोग में हैं, आरक्षित हैं, आदि।

यह चुनौती सरल है: आप इस ग्रिड के सभी असाइन किए गए कोड को STDOUT में प्रिंट कर सकते हैं , सादे ASCII का उपयोग करके, जैसा कि नीचे दिखाया गया है:

AA    AC AD AE AF AG    AI       AL AM AN AO AP AQ AR AS AT AU    AW AX    AZ
BA BB    BD BE BF BG BH BI BJ    BL BM BN BO    BQ BR BS BT BU BV BW BX BY BZ
CA    CC CD    CF CG CH CI    CK CL CM CN CO CP    CR CS    CU CV CW CX CY CZ
            DE    DG       DJ DK    DM    DO                            DY DZ
EA    EC    EE EF EG EH             EM       EP    ER ES ET EU EV EW         
                        FI FJ FK FL FM    FO       FR                FX      
GA GB GC GD GE GF GG GH GI       GL GM GN    GP GQ GR GS GT GU    GW    GY   
                              HK    HM HN          HR    HT HU               
   IB IC ID IE                   IL IM IN IO    IQ IR IS IT IU IV IW IX IY IZ
JA          JE                      JM    JO JP                              
            KE    KG KH KI          KM KN    KP    KR             KW    KY KZ
LA LB LC       LF       LI    LK                   LR LS LT LU LV       LY   
MA    MC MD ME MF MG MH       MK ML MM MN MO MP MQ MR MS MT MU MV MW MX MY MZ
NA    NC    NE NF NG    NI       NL       NO NP    NR    NT NU             NZ
OA                                  OM                                       
PA          PE PF PG PH PI    PK PL PM PN          PR PS PT       PW    PY   
QA                                  QM QN QO QP QQ QR QS QT QU QV QW QX QY QZ
RA RB RC    RE       RH RI       RL RM RN RO RP       RS    RU    RW         
SA SB SC SD SE SF SG SH SI SJ SK SL SM SN SO       SR SS ST SU SV    SX SY SZ
TA    TC TD    TF TG TH    TJ TK TL TM TN TO TP    TR    TT    TV TW       TZ
UA                UG          UK    UM                US                UY UZ
VA    VC    VE    VG    VI             VN                   VU               
               WF                WL       WO          WS       WV            
XA XB XC XD XE XF XG XH XI XJ XK XL XM XN XO XP XQ XR XS XT XU XV XW XX XY XZ
            YE                                           YT YU YV            
ZA                                  ZM             ZR             ZW       ZZ

(अगर मैंने इसे कॉपी करने में कोई गलती की है, तो इस पोस्ट में यहाँ दी गई चुनौती चुनौती के लिए आदर्श है, विकिपीडिया पर नहीं है।)

आप प्रत्येक पंक्ति में अनुगामी व्हॉट्सएप का उपयोग कर सकते हैं या नहीं कर सकते हैं, जिसमें *Zकोड नहीं है, लेकिन उस पंक्ति में 77 वें वर्ण से परे नहीं है (अर्थात, अधिकतम, आप इसे आयताकार ब्लॉक बना सकते हैं, जो कि Zs और रिक्त स्थान पर समाप्त होता है )। इसके अलावा, आप अंत में एक एकल अनुगामी नई लाइन का उपयोग कर सकते हैं या नहीं कर सकते हैं।

यह कोड गोल्फ है, इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।


आपका उदाहरण किस तालिका से मेल खाने वाला है? YT(मैयट) की चूक एक निरीक्षण है?
ग्रेग हेविगेल

@GregHewgill हाँ धन्यवाद। मैं इसे ठीक कर दूंगा, लेकिन किसी भी अन्य विसंगति के लिए, इस पोस्ट में तालिका प्रामाणिक है (यह चुनौती के लिए वास्तव में मायने नहीं रखता, अगर एक कोड गायब है या बहुत अधिक है)।
मार्टिन एंडर

जवाबों:


7

CJam, 125 122 121 बाइट्स

"^Kéÿ·^?{ÿ·¿oÂ^Ú^À:ð^×à^Cé^Dÿ^Ýú^À^K^V^G^Áïþ ,^@^K^ÍBù(^_+óÿþºMa^À^H^@#ï^\¨^@ÿÿ¦|¨ÿþ}íßÕ^Ø\"^Â^Nª^P ^D^R$?ÿÿð^À^AÂ^@!^I"256b2b'[,65>_m*]z{~S2*?}%26/Sf*N*

उपरोक्त नियंत्रण पात्रों के लिए कैरट नोटेशन का उपयोग करता है।

ऑनलाइन दुभाषिया के लिए प्रिंट करने योग्य संस्करण ( 141 बाइट्स ) :

"J`ki4#'Tr{$V!AcG)\d6o+rW97;#1|jN!WXL%GRuqYos0xCaaBzYgN97DOA'f@#@k'867BrCc1h?&d0LBq[st0YW^?b2Jfx.&gG:O(&"31f-95b2b'[,65>_m*]z{~S2*?}%26/Sf*N*

उदाहरण चलाते हैं

$ base64 -d > cc.cjam <<< Igvp/7d/e/+3v2/CmoA68JfgA+kE/536gAsWB4Hv/iAsAAuNQvkoHyvz//66TWGACAAj7xyoAP//pnyo//597d/VmFwigg6qECAEEiQ////wgAHCACEJIjI1NmIyYidbLDY1Pl9tKl16e35TMio/fSUyNi9TZipOKg==
$ LANG=en_US cjam cc.cjam
AA    AC AD AE AF AG    AI       AL AM AN AO AP AQ AR AS AT AU    AW AX    AZ                                                                                                                                      
BA BB    BD BE BF BG BH BI BJ    BL BM BN BO    BQ BR BS BT BU BV BW BX BY BZ                                                                                                                                      
CA    CC CD    CF CG CH CI    CK CL CM CN CO CP    CR CS    CU CV CW CX CY CZ                                                                                                                                      
            DE    DG       DJ DK    DM    DO                            DY DZ                                                                                                                                      
EA    EC    EE EF EG EH             EM       EP    ER ES ET EU EV EW                                                                                                                                               
                        FI FJ FK FL FM    FO       FR                FX      
GA GB GC GD GE GF GG GH GI       GL GM GN    GP GQ GR GS GT GU    GW    GY   
                              HK    HM HN          HR    HT HU               
   IB IC ID IE                   IL IM IN IO    IQ IR IS IT IU IV IW IX IY IZ
JA          JE                      JM    JO JP                              
            KE    KG KH KI          KM KN    KP    KR             KW    KY KZ
LA LB LC       LF       LI    LK                   LR LS LT LU LV       LY   
MA    MC MD ME MF MG MH       MK ML MM MN MO MP MQ MR MS MT MU MV MW MX MY MZ
NA    NC    NE NF NG    NI       NL       NO NP    NR    NT NU             NZ
OA                                  OM                                       
PA          PE PF PG PH PI    PK PL PM PN          PR PS PT       PW    PY   
QA                                  QM QN QO QP QQ QR QS QT QU QV QW QX QY QZ
RA RB RC    RE       RH RI       RL RM RN RO RP       RS    RU    RW         
SA SB SC SD SE SF SG SH SI SJ SK SL SM SN SO       SR SS ST SU SV    SX SY SZ
TA    TC TD    TF TG TH    TJ TK TL TM TN TO TP    TR    TT    TV TW       TZ
UA                UG          UK    UM                US                UY UZ
VA    VC    VE    VG    VI             VN                   VU               
               WF                WL       WO          WS       WV            
XA XB XC XD XE XF XG XH XI XJ XK XL XM XN XO XP XQ XR XS XT XU XV XW XX XY XZ
            YE                                           YT YU YV            
ZA                                  ZM             ZR             ZW       ZZ

10

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

सीधा द्विआधारी एन्कोडिंग कार्यान्वयन।

R=range(26)
print"\n".join(" ".join(chr(65+r)+chr(65+c)if int("8hfxckgq1olihfa47x3rrdkojzkklec7qk1hp4ht6avmzxfg7c4uv14xe0pzvvg93x81ag2bf88v2w0p3p08g8nwtuktbwosj9dytset3qmhdl72v5u62nepapgabdqqu7x",36)&1<<c+r*26 else"  "for c in R)for r in R)

पूर्णांक बनाने के लिए स्क्रिप्ट त्वरित और गंदा है:

codes="""AA    AC AD AE AF AG    AI       AL AM AN AO AP AQ AR AS AT AU    AW AX    AZ
BA BB    BD BE BF BG BH BI BJ    BL BM BN BO    BQ BR BS BT BU BV BW BX BY BZ
CA    CC CD    CF CG CH CI    CK CL CM CN CO CP    CR CS    CU CV CW CX CY CZ
            DE    DG       DJ DK    DM    DO                            DY DZ
EA    EC    EE EF EG EH             EM       EP    ER ES ET EU EV EW         
                        FI FJ FK FL FM    FO       FR                FX      
GA GB GC GD GE GF GG GH GI       GL GM GN    GP GQ GR GS GT GU    GW    GY   
                              HK    HM HN          HR    HT HU               
   IB IC ID IE                   IL IM IN IO    IQ IR IS IT IU IV IW IX IY IZ
JA          JE                      JM    JO JP                              
            KE    KG KH KI          KM KN    KP    KR             KW    KY KZ
LA LB LC       LF       LI    LK                   LR LS LT LU LV       LY   
MA    MC MD ME MF MG MH       MK ML MM MN MO MP MQ MR MS MT MU MV MW MX MY MZ
NA    NC    NE NF NG    NI       NL       NO NP    NR    NT NU             NZ
OA                                  OM                                       
PA          PE PF PG PH PI    PK PL PM PN          PR PS PT       PW    PY   
QA                                  QM QN QO QP QQ QR QS QT QU QV QW QX QY QZ
RA RB RC    RE       RH RI       RL RM RN RO RP       RS    RU    RW         
SA SB SC SD SE SF SG SH SI SJ SK SL SM SN SO       SR SS ST SU SV    SX SY SZ
TA    TC TD    TF TG TH    TJ TK TL TM TN TO TP    TR    TT    TV TW       TZ
UA                UG          UK    UM                US                UY UZ
VA    VC    VE    VG    VI             VN                   VU               
               WF                WL       WO          WS       WV            
XA XB XC XD XE XF XG XH XI XJ XK XL XM XN XO XP XQ XR XS XT XU XV XW XX XY XZ
            YE                                           YT YU YV            
ZA                                  ZM             ZR             ZW       ZZ
"""
n = sum(1 << (x/3) for x in range(0, len(codes), 3) if codes[x] != " ")
def baseN(num,b,numerals="0123456789abcdefghijklmnopqrstuvwxyz"):
    return ((num == 0) and numerals[0]) or (baseN(num // b, b, numerals).lstrip(numerals[0]) + numerals[num % b])
print baseN(n, 36)

1
आप 4 बाइट्स का उपयोग करके बचत करते हैं R=range(26)
फल्को

1
@ फालो: यह काम नहीं करेगा क्योंकि मुझे दो पुनरावृत्तियों की आवश्यकता है। ओह रुको, यह अजगर 2 है, जहां सीमा एक सूची लौटाती है!
ग्रेग हेविगेल

ओह, और 4 और लेखन ...,36)&1<<c+r*26else...। - क्या आप बेस -36 पूर्णांक बनाने के लिए अपनी स्क्रिप्ट पोस्ट करने का मन करेंगे?
फल्को

@ फालो: धन्यवाद, केवल 3 क्योंकि 26elseपारगम्य नहीं है। मुझे लगा कि मैंने कोष्ठक को हटाने की कोशिश की है, लेकिन मुझे उस समय कुछ और गलत लगा होगा!
ग्रेग हेविल

ठीक है, यह दुभाषिया पर निर्भर करता है। मेरा पायथन 2.7.8 अनुमति देता है 26else। (पाइथन २.
फाल्को १३'१४ को

6

रूबी, 269 ​​246 241 235 227

g="b6wapsm769n90ongzuvadg5vdat6ap7v1oyyie3j5wxbq9xtycezrtt9xamn9riqnnxnsxjx0al8uk8rmk5snb7quly7t5i9rkq21r1vnns5vdm7gwzqtxwwwmj02nqxlhl".to_i 36
l=*?A..?Z
676.times{|i|print g.to_s(2)[i]==?1?l[i/26]+l[i%26]:"  ",i%26==25?$/:" "}

gएक मैट्रिक्स है जहां प्रत्येक सेल में एक देश कोड होता है एक 1और सभी अन्य होते हैं 0। सभी पंक्तियों को पीछे लिखा गया है और परिणामी बाइनरी संख्या को आधार 36 प्रतिनिधित्व में बदल दिया गया है। तब मैं सिर्फ सभी कोशिकाओं पर पुनरावृति करता हूं और जांचता हूं कि क्या कोड प्रिंट होगा।


2
PPCG में आपका स्वागत है! रूबी युक्तियों में से कुछ: आप {|i|...}इसके बजाय उपयोग कर सकते हैं do|i|...end, और इसके ठीक बाद |i|(लाइन ब्रेक के बिना) पहला बयान भी शुरू कर सकते हैं । अनुगामी रेखा विराम के बिना प्रिंट करने का एक छोटा तरीका है $><<। आप के "\n"साथ $/और "1"साथ बदल सकते हैं ?1। और वर्णमाला उत्पन्न करने का एक छोटा तरीका है l=[*?A..?Z]*'';)
मार्टिन एंडर

2
इसके अतिरिक्त, आप वर्णमाला को सरणी के रूप में उपयोग कर सकते हैं, इसे स्ट्रिंग में शामिल करने की कोई आवश्यकता नहीं है।
मैनेटवर्क

धन्यवाद! अगर मैं एक मैट्रिक्स के printसाथ प्रतिस्थापित करता हूं और मुद्रित किया जाता है। मैं इसका सही तरीके से उपयोग कैसे करूं? $><<truefalse
स्टीवेक्रॉस

1
वरीयता का समस्या नहीं प्रतीत होता है <<की एक विधि है $>, तो आप उपयोग कोष्टक के लिए है: $><<(1==2?3:4)। वैसे, मुझे सबसे कम 231 अक्षर मिले: pastebin.com/iabBNh6S
मैनेटवर्क

1
नहीं, मुझे नहीं लगता। लेकिन चाहे आप उपयोग करें printया $><<, केवल एक का उपयोग करें। printके साथ अलग-अलग मापदंडों को स्वीकार करता है ,, क्योंकि $><<आप आउटपुट के लिए दो टुकड़े कर सकते हैं।
मैनावर्क

4

CJam, 152 149 148 145 144 140 139 बाइट, प्रिंट करने योग्य

". QH%$ydK0]cg:WSSlFu0z>O$T1<hO)Q63@D7;\KDJ^!NQN!tFr'>x@*!nf`Ut<s=N_[\%Ec0AXXZ`hayqIi'qj)jnonEj!n(ZjpjW("31f-96b2b'[,65>_m*]z{~SS+?S}%52/N*

पॉइंटर्स के लिए धन्यवाद डेनिस।

बहुत सीधा-सादा तरीका। यह काम किस प्रकार करता है:

". Q .... jW("                "Push this string to stack. This is a compressed string"
                              "which results to a 26 by 26 grid of 0 and 1 representing"
                              "whether that block contains country code or empty space";
              31f-96b2b       "Remove 31 from ASCII code of each of the character,"
                              "treat the number array as of base 96 and convert it to"
                              "a base 2 number";
'[,                           "Create an array of characters of ASCII code 0 to 91";
   65>                        "Take last 26 characters, which are A to Z";
      _m*                     "Copy the array and create all combinations {XX|X ∈ [A,Z]}";
         ]z                   "zip the first 26*26 array of 1 and 0 with the above"
                              "26*26 array of XX such that the final array element"
                              "is like ([B XX]|B={0,1},X∈[A,Z])";
           {~SS+?S}%          "For element, unwrap it from array, put "  " to stack,"
                              "if first number is 1, take XX otherwise, the spaces"
                              "and put a single space after each element";
                    52/       "split the array into chunks of 52,i.e 26 XX and 26 spaces";
                       N*     "Join each chunk of 52 elements with new line"

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

(अब केवल अगर मुझे पता है कि एक गैर मुद्रण योग्य चरित्र संस्करण कैसे करना है)


मैंने पहले आपके उत्तर पर ध्यान नहीं दिया। मेरे अंतिम संपादन के बाद, मेरा दृष्टिकोण आपके लिए काफी समान है (लेकिन अभी भी एक कदम पीछे है)। 1. :iजरूरत नहीं है; bअपने दूसरे तर्क के रूप में एक स्ट्रिंग के साथ ठीक काम करता है। 2. यदि आप '[,इसके बजाय उपयोग करते हैं 91,, तो आपको आवश्यकता नहीं है :c
डेनिस

@ डेनिस धन्यवाद! मैं वास्तव में '[,65>मार्ग की कोशिश की , लेकिन मैं अभी भी एक के :cबाद एक ही बाइट्स के लिए अग्रणी डाल रहा था , इस प्रकार इसका इस्तेमाल नहीं किया: D
ऑप्टिमाइज़र

3

जावास्क्रिप्ट ईएस 6, 336 322

a='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
alert(r='tr20d,yxurj,soeyn,1migz,rbh14,5hqc,13w82y,z1c,iqx33,l8dmo,1swln,zokqa,tukfz,r8voh,jzd34,mflqi,jzjen,10gn1k,13ycc7,sn0bd,kbb0j,qm2hs,mvf4,13ydj3,18y9c,jzdah'.split(',').map((n,i)=>(1e10+(parseInt(n,36).toString(2))).slice(-26).replace(/./g,(m,j)=>+m?a[i]+a[j]+' ':'   ')).join('\n'))

बड़ी स्ट्रिंग प्रत्येक पंक्ति को बाइनरी में डाल दिया जाता है ( 1यदि वहां एक देश कोड था, 0यदि नहीं) और फिर base36। Http://jsfiddle.net/twduhqz6/1/ पर फ़ायरफ़ॉक्स में इसे आज़माएं ।


2

बैश + कोरुटिल्स, 361

हम चाहते हैं कि combos के मूल regex हटाने नहीं है। रेगेक्स के कुछ हल्के संपीड़न:

a=({A..Z})
f=(BHJKVY CKP BEJQT A-DFHILNP-X BDI-LNOQX-Z A-HNPQS-WYZ JKOVXZ A-JLO-QSV-Z AF-KP B-DF-LNQ-Z A-DFJ-LOQS-VX DEGHJL-QWXZ BIJ BDHJKMNQSV-Y B-LN-Z B-DJO-QUVXZ B-L DFGJKQRTVX-Z PQW BEIQSUXY B-FH-JLN-RT-X BDFHJ-MO-TV-Z A-EG-KMNP-RTUW-Z _ A-DF-SW-Z B-LN-QS-VXY)
for i in ${!a[@]};{
s+="${a[i]}[${f[i]}]|"
}
echo {A..Z}{A..Z}|sed -r "s/Z /Z\n/g;s/${s%|}/  /g"

2

हास्केल, 357

अरे, यह थोड़े कठिन है।

import Data.List.Split
az=['A'..'Z']
k=0x9084004380010ffffffc24482004085570414419abfbb7be7fff153e65ffff001538f7c400100186b25d7fffcfd4f8149f42b1d00034047ff781e068d0015fb9ff2097c007e90f5c015943f6fdedffdefeedff97d
l i (a:b)|i`mod`2>0=a:l(i`div`2)b|1>0="  ":l(i`div`2)b
l _ _=[]
main=putStr$unlines$chunksOf 78$unwords$l k[a:[b]|a<-az,b<-az]

संकलित करने के लिए प्रिंट (जब मुख्य)। उचित संपीड़न का उपयोग करने से यह बहुत छोटा हो जाएगा ... विचारों का स्वागत है


1

जावास्क्रिप्ट (E6) 350

इस कार्य के लिए सही उपकरण नहीं है (शायद String.fromCharCode के लिए धन्यवाद ?)

r=0,Q=x=>String.fromCharCode(x+64),
console.log("2dff97d 3ff7bfb 3f6fded 3005650 7e90f5 825f00 15fb9ff 1a3400 3ff781e d011 342b1d0 13e0527 3fffcfd 21ac975 1001 14e3df1 3fff001 54f997 3be7fff 26afeed 3041441 102155 244820 3ffffff 380010 2421001"
.replace(/\w+./g,x=>{for(x='0x'+x,s=c=o='',++r;++c<27;s=' ',x/=2)o+=s+(x&1?Q(r)+Q(c):'  ');return o+'\n'}))

1

जे, 172 वर्ण (प्रिंट करने योग्य)

echo}:"1,.u:32+(26 26$,(6#2)#:34-~3 u:
'QKa]?a@a`YQXa$HJ"\^+AB"`F&a[Y\B"N8#Z)QaD"N""P/2QFJ)TQUaa\\58("$""E]STJ"1aaKITJaa[_]?a7H$,$%LJ2*"24+%aaaa$"">*"*2F'
)*0,"1~33+,"0/~i.26

सुगमता के लिए लाइन ब्रेक। सीधा द्विआधारी पैकिंग, छह बिट प्रति स्ट्रिंग चरित्र के साथ (34 मुद्रण योग्य रेंज में और साथ ही बचने के लिए ऑफसेट ')।


1

वोल्फ्राम भाषा, 244 255 बाइट्स

Table[Table[If[BitGet[36^^b6wapsm769n90ongzuvadg5vdat6ap7v1oyyie3j5wxbq9xtycezrtt9xam\n9riqnnxnsxjx0al8uk8rmk5snb7quly7t5i9rkq21r1vnns5vdm7gwzqtxwwwmj02nqxl\hl,675-i*26-j]==1,FromCharacterCode[{i,j}+65]<>" ","   "],{j,0,25}]<>"\n",{i,0,25}]<>""

फायरफ्लेम 241 के उत्तर के नंबर का उपयोग किया गया और उसे 36-एरी फॉर्म में वापस भेज दिया गया।

कोई बिल्ट देश डेटा का उपयोग नहीं किया गया था।



0

सी, 373 बाइट्स

main(i,j){char e[]="0BHJKVY|0CKP|0BEJQT|EGJKLMOYZ|0BDIJKLNOQXYZ|IJKLMORX|0JKOVXZ|KMNRTU|0AFGHIJKP|AEMOP|EGHIMNPRWYZ|ABCFIKRSTUVY|0BIJ|0BDHJKMNQSVWXY|AM|0BCDJOPQUVXZ|0BCDEFGHIJKL|0DFGJKQRTVXYZ|0PQW|0BEIQSUXY|AGKMSYZ|ACEGINU|FLOSV|0|ETUV|AMRWZ",*t,*p=e,*s="|";for(i=0;t=strtok(p,s);p=0,i++)for(j=0;j<27;j++)printf(j-26?!strchr(t,65+j)^(*t!=48)?"%c%c ":"   ":"\n",65+i,65+j);}

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


0

वोल्फ्राम भाषा, 389 बाइट्स

c=CountryData;r=Riffle;StringReplace[""<>r[#~r~" "&/@Array[CharacterRange["A","Z"][[{##}]]&,{26,26}],n="
"],{"GZ"|"WE"->"  ",x:("X"~~_~~" "|n)|##&@@(Cases[#~c~"CountryCode"&/@c[],_String]~Join~(""<>#&/@Partition[Characters@"AACPSXQNICRANTAPEAQPEPEUMQQRCSXQXDGCWLRNTPEVAQUMQVEWLRPIXDYUMQSUMQWVEFRBQYVIBXEMQMQOAQZRBLFRBUKRLIBVIUKGSSFXHRMQTFLIVIWOARIYVIZZRHMFIOAXJA",2,1])):>x,Except@n->" "}]

अधिक पठनीय:

c = CountryData; r = Riffle; StringReplace[
 "" <> r[#~r~" " & /@ 
    Array[CharacterRange["A", "Z"][[{##}]] &, {26, 26}], 
   n = "\n"], {"GZ" | "WE" -> "  ", 
  x : ("X" ~~ _ ~~ " " | n) | ## & @@ (Cases[#~c~"CountryCode" & /@ 
        c[], _String]~
      Join~("" <> # & /@ 
        Partition[
         Characters@
          "AACPSXQNICRANTAPEAQPEPEUMQQRCSXQXDGCWLRNTPEVAQUMQVEWLRPIXDY\
UMQSUMQWVEFRBQYVIBXEMQMQOAQZRBLFRBUKRLIBVIUKGSSFXHRMQTFLIVIWOARIYVIZZR\
HMFIOAXJA", 2, 1])) :> x, Except@n -> " "}]

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

स्पष्टीकरण:

  • ""<>r[r[#," "]&/@Array[CharacterRange["A","Z"][[{##}]]&,{26,26}],n="\n"] "A" से "Z" अक्षरों के सभी जोड़े का एक स्ट्रिंग सरणी है।
  • #~c~"CountryCode"&/@c[](जहाँ c=CountryDataपहले परिभाषित किया गया है) उन सभी देश कोडों की एक सूची देता है जिनके बारे में वोल्फ़्राम भाषा जानती है। इनमें से एक जोड़े हैं Missing["NotApplicable"], इसलिए हम उन लोगों को हटा देते हैं Cases[...,_String]
  • (""<>#&/@Partition[Characters@"AACP...AXJA",2,1])मैन्युअल रूप से 138 वर्ण स्ट्रिंग का उपयोग करते हुए शेष देश कोड में से 83 बनाता है, जहां आसन्न वर्णों के जोड़े आवश्यक देश कोड हैं। यह तार हाथ से कम या ज्यादा पाया गया (जिसकी मदद सेFindPostmanTour फ़ंक्शन ) , और कुछ पुनरावृत्ति है, इसलिए यहां संभावित रूप से अधिक गोल्फिंग की जानी है।
  • StringReplace[ <full array> ,{"GZ"|"WE"->" ",x:("X"~~_~~" "|n)|##&@@( <known country codes> ~Join~ <extra codes> ):>x,Except@n->" "}]पहले दो कोड, "GZ" और "WE" से छुटकारा मिलता है, जो वोल्फ्राम सोचता है कि देश कोड हैं लेकिन तालिका के अनुसार नहीं हैं; फिर "X" से शुरू होने वाले सभी कोड से मेल खाता है, और ज्ञात कोड और जिन्हें हमने मैन्युअल रूप से जोड़ा है, और उन्हें खुद से बदलता है; फिर अंत में वह सब कुछ जो एक नई रेखा नहीं है और पहले से ही मेल नहीं खाता है को एक स्थान में बदल दिया गया है।

1
यह पता चला है कि बाहरी "GZ" और "WE" गाजा पट्टी और वेस्ट बैंक के लिए खड़े हैं। क्या यह पहली बार है कि इज़राइल में संघर्ष ने एक कोड गोल्फ चुनौती को प्रभावित किया है?
पेड़ नहीं

0

जेली , 121 120 112 110 बाइट्स (गैर-प्रतिस्पर्धात्मक)

“VV&ØṖgḳeƘKo⁾lc<Ṗɗẋ⁾ÆȤ¡rżQ5¤ø^k&`v®tḊẒḂṁz®ṙṂþ°~7<¹ṢƝƒ4ṇæÇZt9ẈÇḞƲY!u`İŀo0*dḅḥmȯḊȧṛƓXĠƈṾ’Bx2ða»32øØAp`OFµỌs2s26G

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

-8 बाइट्स @ डेनिस को धन्यवाद

कार्टिसियन उत्पादों के @ डेनिस के विचार के लिए -2 बाइट्स धन्यवाद

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

सरल: कार्यक्रम आउटपुट को अधिकांश प्राप्त करने के लिए एक और बड़ी सूची के साथ एक बड़ी बाइनरी सूची को गुणा करता है, फिर इसे प्रारूपित करता है

माध्यम: कार्यक्रम बड़ी बाइनरी सूची को एनकोड करता है

1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1

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

निचला स्तर:

प्रोग्राम का अधिकांश भाग इनकोडिंग डेटा का उपयोग करता है:

“VV&ØṖgḳeƘKo⁾lc<Ṗɗẋ⁾ÆȤ¡rżQ5¤ø^k&`v®tḊẒḂṁz®ṙṂþ°~7<¹ṢƝƒ4ṇæÇZt9ẈÇḞƲY!u`İŀo0*dḅḥmȯḊȧṛƓXĠƈṾ’

यह एक बेस -250 पूर्णांक है जो दशमलव संख्या रखता है 233462323092263584350936137603939798267906095227198731310610883427614237299604158551774020670253062350084519623333781892392013977676150946873601610983221266427394582295973500719992107281184544524840476937 , जो उपरोक्त बाइनरी सूची में बदल जाता है।

संक्षिप्तता के लिए, आइए इस मूल्य पर कॉल करें cऔर cस्पष्टीकरण के साथ लंबे स्ट्रिंग को बदलें

cBx2ða»32øØAp`OFµỌs2s26G   - main link, takes no input
c                          -  literal value
 B                         -  convert this to binary to get a list
                                       representing which codes are assigned
  x2                       -   repeat each element twice
    ða»32                  - element-wise product (dealing with 
                                       spaces) with...
         øØAp`OF           -  every possible country code in ASCII codes.
                µỌs2s26G   - format the output to be correct

;⁶$€Fs78;⁷$€से बदला जा सकता है s26G
डेनिस

संकेत: कार्टेशियन उत्पादों में देखें। आपको रिक्त स्थान की आवश्यकता नहीं है; Gरिक्त स्थानों के साथ खाली तार पैड जाएगा।
डेनिस

मुझे लगता है कि यह गैर-प्रतिस्पर्धात्मक है।
एग्रीकल्चर से एरिक

हाँ, भाषा चुनौती से नई है।
mbomb007
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.