Imprimir todos los códigos de país

24

ISO 3166-1 es el estándar que define todos los códigos de país. Los conocidos códigos de dos letras (US, GB, JP, etc.) se denominan códigos Alpha-2.

Con dos letras, solo hay 26 2 = 676 códigos posibles, que se pueden organizar muy bien en una cuadrícula. Esta tabla puede ser útil como una descripción general, para ver qué códigos están realmente en uso, reservados, etc.

Este desafío es simple: debe imprimir todos los códigos asignados de esta cuadrícula a STDOUT, utilizando ASCII simple, exactamente como se muestra a continuación:

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

(Si cometí algún error al copiarlo, la tabla aquí en esta publicación es normativa para el desafío, no la de Wikipedia).

Puede usar o no espacios en blanco al final de cada línea que no contenga el *Zcódigo, pero no más allá del 77. ° carácter de esa línea (es decir, a lo sumo, puede convertirlo en un bloque rectangular que termine en Zsy espacios). Además, puede o no usar una sola línea final al final.

Este es el código de golf, por lo que gana la respuesta más corta (en bytes).

code-golf kolmogorov-complexity Martin Ender
fuente
¿Con qué tabla se supone que coincide tu ejemplo? ¿La omisión de YT(Mayotte) es un descuido?
Greg Hewgill
@GregHewgill Sí, gracias. Lo arreglaré, pero para cualquier otra discrepancia, la tabla en esta publicación es normativa ( realmente no importa para el desafío, si falta un código o es demasiado).
Martin Ender

Respuestas:

7

CJAM, 125 122 121 bytes

"^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*

Lo anterior utiliza la notación de intercalación para los caracteres de control.

Versión imprimible ( 141 bytes ) para el intérprete en línea :

"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*

Ejecución de ejemplo

$ 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
Dennis
fuente
10

Python 2, 240 bytes

Implementación directa de codificación binaria.

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)

El script para generar el entero es rápido y sucio:

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)
Greg Hewgill
fuente
1
Ahorras 4 bytes usando R=range(26).
Falko
1
@Falko: Eso no funcionará porque necesito dos iteradores. ¡Oh, espera, esto es python 2, donde range devuelve una lista!
Greg Hewgill
Ah, y 4 más escritos ...,36)&1<<c+r*26else.... - ¿Te importaría publicar tu script para generar el entero base 36?
Falko
@Falko: Gracias, solo 3 porque 26elseno se puede analizar. ¡Pensé que había intentado eliminar los paréntesis, pero debo haber tenido algo más mal en ese momento!
Greg Hewgill
Ok, parece depender del intérprete. Mi Python 2.7.8 lo permite 26else. (Python 2.7.6, sin embargo, no.)
Falko
6

Rubí, 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?$/:" "}

ges una matriz donde cada celda que tiene un código de país es ay 1todas las demás lo son 0. Todas las filas se escriben detrás y el número binario resultante se ha convertido en una representación de base 36. Luego solo itero sobre todas las celdas y verifico si se imprimirá el código.

stevecross
fuente
2
Bienvenido a PPCG! Algunos consejos de Ruby: puede usar en {|i|...}lugar de do|i|...end, y también comenzar la primera declaración justo después |i|(sin salto de línea). Una forma más corta de imprimir sin salto de línea final es $><<. Puede reemplazar "\n"con $/y "1"con ?1. Y una forma más corta de generar el alfabeto es l=[*?A..?Z]*'';)
Martin Ender
2
Además, puede usar el alfabeto como matriz, no es necesario unirlo en una cadena.
manatwork
¡Gracias! Si lo reemplazo printcon $><<una matriz de truey falseestá impreso. ¿Cómo uso esto correctamente?
stevecross
1
Aparece el problema de precedencia que <<es un método $>, por lo que tiene que utilizar paréntesis: $><<(1==2?3:4). Por cierto, lo más corto que obtuve de esto son 231 caracteres: pastebin.com/iabBNh6S .
manatwork
1
No, no lo creo. Pero independientemente de si usa printo $><<, use solo uno. printacepta múltiples parámetros separados con ,, para $><<que pueda concatenar las dos piezas a la salida.
manatwork
4

CJam, 152 149 148 145 144 140 139 bytes, imprimible

". 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*

Gracias Dennis por los consejos.

Enfoque bastante sencillo. Cómo funciona:

". 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"

Pruébalo en línea aquí

(Ahora solo si supiera cómo hacer una versión de personaje no imprimible)

Optimizador
fuente
No presté atención a tu respuesta antes. Después de mi última edición, mi enfoque es bastante similar al tuyo (pero aún un paso atrás). 1. :ino es necesario; bfunciona bien con una cadena como segundo argumento. 2. Si usa en '[,lugar de 91,, no necesita :c.
Dennis
@ Dennis Gracias! Realmente probé la '[,65>ruta, pero todavía estaba poniendo un :cdespués que conducía a los mismos bytes, por lo que no la usé: D
Optimizer
3

JavaScript ES6, 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'))
Expandir fragmento

La cadena grande es cada fila puesta en binario ( 1si había un código de país allí, 0si no) y luego base36. Pruébelo en Firefox en http://jsfiddle.net/twduhqz6/1/ .

NinjaOsoMono
fuente
2

Bash + coreutils, 361

Eliminación básica de expresiones regulares de los combos que no queremos. Alguna compresión leve de la expresión regular:

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"
Trauma digital
fuente
2

Haskell, 357

Maldición, esto es un poco difícil.

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]

Imprime en STDOUT cuando se compila (por lo tanto, el principal). El uso de una compresión adecuada lo haría mucho más corto ... las ideas son bienvenidas

michi7x7
fuente
1

JavaScript (E6) 350

No es la herramienta adecuada para esta tarea (¿quizás gracias a 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'}))
edc65
fuente
1

J, 172 caracteres (imprimible)

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

Saltos de línea para legibilidad. Empaque binario directo, con seis bits por carácter de cadena (desplazamiento 34 para entrar en el rango imprimible y evitar ').

Luciérnaga
fuente
1

Idioma Wolfram, 244 255 bytes

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

El número de la respuesta de fireflame241 se usó y se volvió a empaquetar en forma de 36 arios.

No se utilizaron datos de países incorporados.

Sauron
fuente
0

PHP, 323 bytes

$p=explode(_,"^BHJKVY_^CKP_^BEJQT_EGJKMOYZ_ACE-HMPR-W_I-MORX_^JKOVXZ_KMNRTU_^AF-KP_AEMOP_EGHIMNPRWYZ_ABCFIKR-VY_^BIJ_ACEFGILOPRTUZ_AM_AE-IK-NR-TWY_AM-Z_A-CEHIL-PSUW_^PQW_^BEIQSUXY_AGKMSYZ_ACEGINU_FLOSV_\w_ETUV_AMRWZ");
foreach($r=range(A,Z)as$k=>$v)
foreach($r as$w)echo preg_match("#[{$p[$k]}]#",$w)?$v.$w:"  "," 
"[$w>Y];

Pruébalo en línea!

Jörg Hülsermann
fuente
0

C, 373 bytes

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);}

Pruébalo en línea

Johan du Toit
fuente
0

Wolfram idioma, 389 bytes

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->" "}]

Más legible:

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 -> " "}]

Wolfram tiene una lista incorporada de códigos de país ISO, por lo que este debería ser el idioma perfecto para el trabajo. Sin embargo, solo conoce los códigos de país que en realidad son códigos para países, y no los reservados para otros usos, que todavía se incluyen en esta tabla. Por lo tanto, necesitamos agregar muchos códigos de país manualmente.

Explicación:

  • ""<>r[r[#," "]&/@Array[CharacterRange["A","Z"][[{##}]]&,{26,26}],n="\n"] es un conjunto de cadenas de todos los pares de letras desde "A" hasta "Z".
  • #~c~"CountryCode"&/@c[](donde c=CountryDatase define anteriormente) proporciona una lista de todos los códigos de país que Wolfram Language conoce. Un par de estos son Missing["NotApplicable"], así que los quitamos con Cases[...,_String].
  • (""<>#&/@Partition[Characters@"AACP...AXJA",2,1])crea 83 de los códigos de país restantes manualmente usando una cadena de 138 caracteres, donde los pares de caracteres adyacentes son los códigos de país requeridos. Esta cadena se encontró más o menos a mano (¡con la ayuda de la FindPostmanTourfunción!), Y hay cierta repetición, por lo que potencialmente hay más golf por hacer aquí.
  • StringReplace[ <full array> ,{"GZ"|"WE"->" ",x:("X"~~_~~" "|n)|##&@@( <known country codes> ~Join~ <extra codes> ):>x,Except@n->" "}]primero se deshace de dos códigos, "GZ" y "WE", que Wolfram cree que son códigos de país pero no están de acuerdo con la tabla; luego coincide con todos los códigos que comienzan con "X", más los códigos conocidos y los que agregamos manualmente, y los reemplaza con ellos mismos; entonces, finalmente, todo lo demás que no sea una nueva línea y que no haya sido emparejado se convierte en un espacio.
No un arbol
fuente
1
Resulta que los extraños "GZ" y "WE" representan Franja de Gaza y Cisjordania. ¿Es esta la primera vez que el conflicto en Israel ha afectado un desafío de código de golf?
No es un árbol
0

Jelly , 121 120 112 110 bytes (no competitiva)

“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

Pruébalo en línea!

-8 bytes gracias a @Dennis

-2 bytes gracias a la idea de @ Dennis de productos cartesianos

Cómo funciona

Simple: el programa multiplica una gran lista binaria con otra gran lista para obtener la mayor parte de la salida, luego la formatea

Medio: el programa codifica la lista binaria grande

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

en un gran número, codificando qué códigos de país se asignan. Cada elemento se multiplica por elementos por cada elemento de cada posible código de país para obtener una lista de todos los códigos de país asignados, que luego se formatea en la lista de salida.

Nivel inferior:

La mayor parte del programa utiliza datos codificados en:

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

Es un entero de base 250 que contiene el número decimal 233462323092263584350936137603939798267906095227198731310610883427614237299604158551774020670253062350084519623333781892392013977676150946873601610983221266427394582295973500719992107281184544524840476937, que se convierte en la lista binaria anterior.

Por brevedad, llamemos a este valor cy reemplacemos la cadena larga con cla explicación.

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
fireflame241
fuente
;⁶$€Fs78;⁷$€puede ser reemplazado con s26G.
Dennis
Consejos: busca productos cartesianos. No necesita espacios en blanco; Grellenará cadenas vacías con espacios.
Dennis
Creo que esto no es competitivo.
Erik the Outgolfer
Sí, el lenguaje es más nuevo que el desafío.
mbomb007