Règles

Étant donné un code de pays ISO3166-1-Alpha-2, votre tâche consiste à décider de la direction du trafic pour ce pays:

• L'entrée sera un code de pays valide (valide car c'est un élément des deux listes fournies)
• L'entrée peut être une liste de deux caractères au lieu d'une chaîne si cela aide
• Vous pouvez choisir de saisir des données en minuscules
• Vous choisirez une valeur, disons pour la droite (votre choix) et sortirez cette valeur si le trafic dans ce pays est droitier et tout le reste dans l'autre cas.
• Il vous suffit de gérer les codes de pays contenus dans l'une de ces listes:

Ce sont tous des pays où le trafic est gaucher:

['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']

Et voici tous les pays où le trafic est droitier:

['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']

Par souci d'exhaustivité, voici un fichier CSV qui contient toutes les valeurs ainsi que les noms de pays.

Cas de test

En supposant que vous ayez choisi de générer Lun trafic pour gauchers, voici quelques cas de test valides:

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

Remarque: Il y a une petite chance que j'ai raté un pays ou qu'il y ait une mauvaise classification et je ne changerai pas les spécifications car cela pourrait invalider les réponses. Si j'ai fait une erreur, je m'excuse sincèrement, ne vous en offrez pas!

Python 2 , 145 136 112 109 octets

'TTHSZWMSGSONPKNZMWVIDFKELSCYJPNFJMTVCXBNRBWSHKYAUGGYBTLCCKIMVGBSBBMZAINAGDMOBDIEJEMYMUNUPGSRLKTKTOTCTZ'.find

Essayez-le en ligne!

Sorties -1pour trafic droitier. La chaîne est générée automatiquement avec ce script Retina . Merci à totalement humain pour la chaîne de recherche plus courte de 9 octets. J'ai pu obtenir 24 octets de plus grâce à la suggestion AdmBorkBork .
Obtenu la chaîne de recherche 3 octets plus court à l'aide d'un script python.

Gelée , 61 octets

Un grand merci à @ Mr.Xcoder pour m'avoir aidé à mettre cela ensemble.
Sauvegardé 1 octet grâce à @JonathanAllan

Retours 0pour droitiers ou 1pour gauchers.

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

Essayez-le en ligne!

Comment?

Nous convertissons chaque code de pays en un entier N en l'analysant en base 256 et en appliquant la fonction de hachage suivante, qui est sans collision pour le trafic gaucher vs droitier:

((N * 6) MOD 1513) MOD 566

Cela conduit à la liste de valeurs suivante pour le trafic à gauche:

[   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)

La différence moyenne entre deux entrées consécutives est proche de 8. Nous codons en delta la liste avec des incréments dans la plage [1 ... 16]. Cela signifie que chaque fois qu'un incrément est supérieur à 16, nous devons insérer une valeur intermédiaire sur un emplacement inutilisé (nous devons nous assurer qu'il n'est pas atteint par le trafic droitier). Mais la fonction de hachage a été choisie de telle manière que nous n'avons à le faire que pour quelques positions. Cela donne:

[  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)

Nous convertissons cette liste de base bijective-16 en l'entier suivant:

274705197430389746738026977757328941544772847257562272094076195694133371689429679543810871702

qui devient “ŒỴ¬Ʋ>r¤dị|®ædHẇ⁸ɗH^CŒ³ẇPḷgȤƲȥƓƑ®Ƭṅḅ4ṛḟṄ’dans l'encodage base-250 de Jelly.

Le premier lien reconstruit la liste d'origine à partir de cet entier et le second teste s'il contient le hachage de l'entrée.

“ŒỴ¬Ʋ>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

PowerShell , 161 148 octets

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

Essayez-le en ligne!

Correspondance de motifs regex naïfs . Sorties Truepour gaucher et Falsedroitier.

Économisé 13 octets grâce au mercator jouant au regex.

Haskell , 137 octets

-5 octets grâce aux ovs.

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

Essayez-le en ligne!

Généré la chaîne d'origine à la main.

05AB1E , 82 68 octets

Sorties 1 pour le trafic à gauche et 0 pour le trafic à droite.

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

Essayez-le en ligne! ou comme suite de tests

Utilise la chaîne générée par totalement humain et améliorée par les ovules

05AB1E , 76 octets

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

Essayez-le en ligne!

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

Génère la chaîne suivante:

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

Si je divise cela sur des espaces et entrelace l'alphabet dans chaque chaîne, il en résulte tous les états qui conduisent sur le côté gauche.

1 pour la gauche, 0 pour la droite; Emigna est mieux, mais c'était assez différent pour poster :).

Gelée , 69 octets

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

Un lien monadique prenant une liste de personnages et retournant 1s'il est à gauche ( 0si à droite).

Essayez-le en ligne!

Comment?

Utilise la méthode telle qu'implémentée totalement humaine / ovs .

ẇ“ ... ’ṃØ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?

De plus, ce que j'ai fait indépendamment est arrivé à 72 octets :

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

Également un lien monadique prenant une liste de personnages et retournant 1s'il est à gauche ( 0si à droite).

Essayez-le en ligne!

Comment?

“ ... ’ṃ©Ø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

Befunge, 155 152 147 146 octets

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

Essayez-le en ligne!

Sorties 80pour un pays droitier, et toute autre chose indique un pays gaucher.

Explication

La dernière ligne du code contient une représentation de tous les pays gauchers. Il s'agit d'une liste des premiers caractères des codes de pays, regroupés par leur deuxième caractère. La fin de chaque groupe est marquée par la mise en minuscule du dernier caractère du groupe.

Ainsi, par exemple, le premier groupe Nz,, représente NAet ZA. Le deuxième groupe, BSgreprésente BB, SBet GB. Il existe un groupe pour chaque lettre de l'alphabet, à l'exception de la lettre Q(aucun code de pays à gauche ne se termine par Q). Ce groupe vide est représenté par le caractère {, car cela ne correspondra évidemment à aucun code de pays valide.

Pour déterminer si un code de pays donné correspond à l'une de ces entrées, nous parcourons la liste en vérifiant si l'un des caractères de la liste correspond au premier caractère de notre entrée (mod 32 pour tenir compte de la casse), et aussi que le groupe correspondant , correspond au deuxième caractère de l'entrée. Le caractère de groupe commence comme Aet est incrémenté chaque fois que nous rencontrons une lettre minuscule dans la liste.

Nous quittons lorsque nous trouvons une correspondance, produisant la dernière valeur de caractère sur la pile (qui sera le premier caractère du code de pays - éventuellement en minuscules). Sinon, nous quitterons lorsque nous aurons parcouru toute la liste, auquel cas nous afficherons le dernier numéro de la pile, qui est toujours 80.

Lot Windows, 289 279 199 193 193 181 130 118 octets

@echo TTHSZWMSGSONPKNZMWVIDFKELSCYJPNFJMTVCXBNRBWSHKYAUGGYBTLCCKIMVGBSBBMZAINAGDMOBDIEJEMYMUNUPGSRLKTKTOTCTZ|find "%1"

Sort la chaîne des ovs pour le trafic à gauche, sinon ne sort rien.

Remarque: J'ai remarqué que si l'entrée contient un code de pays dans la liste ci-dessus, elle affichera toujours L. Cependant, cela ne viole pas la règle de contestation car OP mentionné, seuls les codes de pays doivent être traités.

Explication:

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

C (gcc) , 181 169 165 octets

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

Essayez-le en ligne!

Python 2 , 144 octets

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]

Essayez-le en ligne!

Imprime Truepour gauche, Falsepour droite.

Retina , 150 117 bytes

$
MSOBTVGBSBBMZAINAGDMOAUGGYBDBWSHKYBNRJPNFJMVCKIMTLCCXLSCYFKEVIDIEJELSGSOLKNZMWMYMUPKNPGSRNUTKTOTCTZSZWTTH
^(..).*\1

Essayez-le en ligne!

Excel VBA, 118 octets

Fonction de fenêtre immédiate VBE anonyme qui prend l'entrée de la cellule [A1]et les sorties 0si le pays est droitier

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

utilise la chaîne des ovs

Japt, 126 100 97 octets

Utilise la chaîne de recherche des ovs totalement humains . Prend les entrées en minuscules et les sorties falsepour RHD ou trueautre.

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

Essayez-le

Tout entre les accents graves est la chaîne de recherche et compressés et en minuscules øvérifie si elle contient l'entrée, U.

Pyth , 60 57 55 50 47 46 44 octets

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

Exécuter en ligne

Prend l'entrée comme une chaîne entre guillemets majuscules ( 'AI'). Renvoie 3pour gauche et non 3pour droite.

Comment ça marche

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

Générer la chaîne magique

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

sed, 148 + 1 145 + 1 143 + 1 142 + 1 octets

Un octet supplémentaire pour -r indicateur (expressions rationnelles étendues POSIX).

Affiche une chaîne vide pour le trafic à gauche, le code de pays d'origine pour le trafic à droite.

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//

Exemple:

$ 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

$

Historique des modifications expliqué:

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 octets, réponse non vide

Légère variation de la précédente. Retourne Lpour le trafic gaucher.

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/^..//

APL (Dyalog) , 108 octets

1∊⍷∘'TTHSZWMSGSONPKNZMWVIDFKELSCYJPNFJMTVCXBNRBWSHKYAUGGYBTLCCKIMVGBSBBMZAINAGDMOBDIEJEMYMUNUPGSRLKTKTOTCTZ'

Essayez-le en ligne!

Utilisation de la chaîne de recherche par ovs.

Circulation à gauche = 1.
Circulation à droite = 0.

Javascript (ES6), 118 116 octets

Sauvegardé 2 octets grâce à @Craig Ayre

s=>"SZAINAGGDMOAUGBBSCCKIMWSHKYLSBMVGSGYBDBTHBWBNRMZMTLCXSRTVCYPNFKNPKEFJMYVIDIEJPGJEMUNZWMSONULKTKTOTTCTZ".match(s)

Résultats null pour trafic droitier

Cas de test

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

VIM, 117 109 108 frappes

oSZAINAGGDMOAUGBBSCCKIMWSHKYLSBMVGSGYBDBTHBWBNRMZMTLCXSRTVCYPNFKNPKEFJMYVIDIEJPGJEMUNZWMSONULKTKTOTTCTZ␛kg*D

Essayez-le en ligne! (remplacer SEdans l'en-tête par le code du pays)

␛est la touche d'échappement. Le programme imprime le texte suivant pour le trafic droitier:

SZAINAGGDMOAUGBBSCCKIMWSHKYLSBMVGSGYBDBTHBWBNRMZMTLCXSRTVCYPNFKNPKEFJMYVIDIEJPGJEMUNZWMSONULKTKTOTTCTZ

Explication

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

MY-BASIC , 162 octets

Fonction anonyme qui prend les entrées sous forme de chaîne non enveloppée (c'est-à-dire sans parenthèses) et les sorties vers la console

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

Retours 0pour les droitiers et les 1gauchers, essayez-le en ligne!

Yabasic , 127 octets

Fonction anonyme qui prend l'entrée sous forme de chaîne non enveloppée (non "...") et sort 0si le pays est droitier et 1si le pays est gaucher.

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

Essayez-le en ligne!

C (gcc) , 115 107 bytes

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

Essayez-le en ligne!

Retourne 0si gaucher. -4 merci à @JonathanFrech

K, 105 octets

Pour plus d'informations sur les langues K / Q, voir code.kx.com

Utilisation: code pays (chaîne de 2 caractères, exemple "XY") après

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

Génère 1b(trafic pour gauchers) ou 0b(pas pour trafic pour gauchers)

Explication:

• 5h$"XX"génère des codes ascii pour chaque caractère de la chaîne de 2 caractères (code pays), l'exemple 5h$"TB"génère 84 66

• -65+integerListsoustrayez 65 à chaque entier de la liste. L'exemple -65+5h$"TB"génère 19 1

• 26/:integerListcalcule un entier équivalent à cette liste sous forme de chiffres en base 26. L'exemple 26/:-65+5h$"TB"génère 495 (code de pays sous forme d'entier)

• in[;listOfCountryCodesAsIntegers]@xrenvoie une valeur booléenne (1b = vrai, 0b = faux). Vrai si x est dans la liste

• +\-48+5h$"62<729151368=1>a1A23<6<C181A83?45;488F411112115:235Q43r141738353135247F42Tl<:" calcule la liste des nombres entiers pour chaque code de pays avec trafic pour gauchers

  • "62<729151368=1>a1A23<6<C181A83?45;488F411112115:235Q43r141738353135247F42Tl<:"est la «chaîne de distance» (distance entre chaque paire de codes de pays entiers dans l'ordre croissant, codifiée en char). La distance n est codifiée comme ascii car 48 + n

  • -48+5h$".." calcule la valeur ascii de chaque caractère dans la chaîne ".." et récupère la distance d'origine sous forme de code ascii - 48. Le résultat est la liste des distances

  • +\integerList calcule la somme partielle des éléments de la liste -> codes absolus de pays entiers à partir des distances entre les codes.

REMARQUES.-

• Résultats 0b pour tout code de pays non gaucher, y compris les codes de pays non valides
• Nous pouvons enregistrer un caractère reformatant le code, mais nécessite d'écrire le code de pays "XX" à l'intérieur du code (je ne sais pas s'il est valide, mais je suis sûr qu'il n'est pas élégant) in[26/:-65+5h$"XX";+\-48+5h$"..."]