प्लेट से लेकर राज्य तक

Question

यह अनिवार्य रूप से एक अमेरिकी लाइसेंस प्लेट जेनरेट करने का विलोम है

चुनौती: एक स्ट्रिंग को देखते हुए जो नीचे दी गई लाइसेंस प्लेट प्रारूपों में से एक से मेल खाती है, सभी संभव राज्यों को आउटपुट करती है जो उस प्रारूपण से मेल खाती है। नीचे दी गई तालिका में समावेशी के माध्यम से 0एक अंक के लिए खड़ा है , और समावेशी के माध्यम से एक पत्र के लिए खड़ा है । इस चुनौती के प्रयोजनों के लिए, हम जटिल प्रारूप नियमों (जैसे डेलावेयर, जिसमें अंकों की चर संख्या है) के साथ राज्यों की अनदेखी कर रहे हैं, और लुक-अलाइक अक्षरों (जैसे, और ) को हटाने की अनदेखी कर रहे हैं ।09AAZI1

AAA 000: AK, IA, MS, MP, VT
0000: AS
AAA0000: AZ, GA, WA
000 AAA: AR, KS, KY, LA, ND, OR
0AAA000: CA
AA-00000: CT
AA-0000: DC
AAA A00: FL
AA 00000: IL
000A,000AA,000AAA,AAA000: IN
0AA0000: MD
AAA 0000,0AA A00,AAA 000: MI
000-AAA: MN
00A-000: NV
000 0000: NH
A00-AAA: NJ
000-AAA,AAA-000: NM
AAA-0000: NY, NC, PA, TX, VA, WI
AAA 0000: OH
000AAA: OK
AAA-000: PR
000-000: RI
AAA 000,000 0AA: SC
A00-00A: TN
A00 0AA: UT

उदाहरण:

B32 9AG
[UT]

1YUC037
[CA]

285 LOR
[AR, KS, KY, LA, ND, OR] (in any order)

285-LOR
[MN, NM] (in any order)

285LOR
[IN, OK] (in any order)

नियम और स्पष्टीकरण

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

Answer 1

जावास्क्रिप्ट (ईएस 6),  203 202 201  200 बाइट्स

@NahuelFouilleul को 1 बाइट धन्यवाद दिया गया

s=>'xMiAZGAWaMIOhNvInxMNNmARKSKYLANDOrNMPrAKIAMIMSMPSCVtAsMdxScRiNhUtDcCtxFlxNYNCPATXVAWiInIlINOkNjCaTn'.match(/[A-Z]*./g)[s.replace(/./g,c=>c<'!'?0:1/c?9:6-~(c+1))*3%47%30].toUpperCase().match(/../g)

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

कैसे?

इनपुट रूपांतरण

$n$

• रिक्त स्थान बदल दिए गए हैं$0$
• अंकों को बदल दिया जाता है$9$
• पत्रों को बदल दिया जाता है$7$
• हाइफ़न को बदल दिया जाता है$6$

जेएस कोड के रूप में:

c < '!' ?        // if c is a space:
  0              //   replace it with 0
:                // else:
  1 / c ?        //   if c is a digit:
    9            //     replace it with 9
  :              //   else:
    6 - ~(c + 1) //     if c is a hyphen, this gives:
                 //       6 - ~('-1') --> 6 - 0 --> 6
                 //     if c is a letter (e.g. 'A'), this gives:
                 //       6 - ~('A1') --> 6 - ~NaN --> 6 - (-1) --> 7

हैश फंकशन

हम फिर निम्न हैश फ़ंक्शन लागू करते हैं:

$$f(n) = ((3\times n) \bmod 47) \bmod 30$$

$[1..29]$000AAAAA000$24$ , लेकिन यह पूरी तरह से ठीक है क्योंकि इन प्लेट प्रारूपों इंडियाना विशेष रूप से उपयोग किया जाता है।

 format     | n        | * 3       | mod 47 | mod 30 | states
------------+----------+-----------+--------+--------+----------------------
  'AAA 000' |  7770999 |  23312997 |   10   |   10   | AK,IA,MI,MS,MP,SC,VT
     '0000' |     9999 |     29997 |   11   |   11   | AS
  'AAA0000' |  7779999 |  23339997 |   32   |    2   | AZ,GA,WA
  '000 AAA' |  9990777 |  29972331 |    8   |    8   | AR,KS,KY,LA,ND,OR
  '0AAA000' |  9777999 |  29333997 |   28   |   28   | CA
 'AA-00000' | 77699999 | 233099997 |   19   |   19   | CT
  'AA-0000' |  7769999 |  23309997 |   18   |   18   | DC
  'AAA A00' |  7770799 |  23312397 |   21   |   21   | FL
 'AA 00000' | 77099999 | 231299997 |   25   |   25   | IL
     '000A' |     9997 |     29991 |    5   |    5   | IN
    '000AA' |    99977 |    299931 |   24   |   24   | IN
   '000AAA' |   999777 |   2999331 |   26   |   26   | IN,OK
   'AAA000' |   777999 |   2333997 |   24   |   24   | IN
  '0AA0000' |  9779999 |  29339997 |   12   |   12   | MD
 'AAA 0000' | 77709999 | 233129997 |   33   |    3   | MI,OH
  '0AA A00' |  9770799 |  29312397 |    1   |    1   | MI
  '000-AAA' |  9996777 |  29990331 |    7   |    7   | MN,NM
  '00A-000' |  9976999 |  29930997 |   34   |    4   | NV
 '000 0000' | 99909999 | 299729997 |   46   |   16   | NH
  'A00-AAA' |  7996777 |  23990331 |   27   |   27   | NJ
  'AAA-000' |  7776999 |  23330997 |    9   |    9   | NM,PR
 'AAA-0000' | 77769999 | 233309997 |   23   |   23   | NY,NC,PA,TX,VA,WI
  '000-000' |  9996999 |  29990997 |   15   |   15   | RI
  '000 0AA' |  9990977 |  29972931 |   44   |   14   | SC
  'A00-00A' |  7996997 |  23990991 |   29   |   29   | TN
  'A00 0AA' |  7990977 |  23972931 |   17   |   17   | UT

राज्य एन्कोडिंग

सभी स्टेट पैटर्न एक साथ एक स्ट्रिंग में शामिल होते हैं, प्रत्येक पैटर्न कम केस लेटर के साथ समाप्त होता है। खाली स्लॉट एक मनमानी से भरे होते हैं x।

[ [], [ 'MI' ], [ 'AZ', 'GA', 'WA' ], [ 'MI', 'OH' ], ... ] --> 'xMiAZGAWaMIOh...'

match(/[A-Z]*./g)$f(n)$

अंत में, पैटर्न ही पूर्ण ऊपरी मामले में बदल जाता है और 2 वर्णों के समूहों में विभाजित हो जाता है।

Comments

मैं प्यार करता हूँ कि आप हमेशा एक स्ट्रिंग से संबंधित समस्या के लिए इस तरह के सुरुचिपूर्ण गणितीय समाधान के साथ कैसे आते हैं। :)

— AdmBorkBork

डी 'ओह! मैं आज एक अच्छा दिन नहीं कर रहा हूँ, मैं हूँ ?!

— शैगी

बहुत चतुर विधि! दो प्लेट प्रारूप जो टकराते हैं वह इंडियाना नहीं बल्कि इंडियाना हैं।

— ब्रैडॉक

[A-Z]*.इसके बजाय .*?[a-z]एक बाइट को बचाना चाहिए

— नाहुएल फौइलुल

@NahuelFouilleul मैंने पहले भी वह गलती की है ... धन्यवाद!

— अर्नुलद

Answer 2

टी-एसक्यूएल, 475 बाइट्स

SELECT STUFF(value,1,8,'')
FROM STRING_SPLIT('000 0000NH|000 055 SC|000 555 AR,KS,KY,LA,ND,OR|0000    AS|000-000 RI|0005    IN|00055   IN|000555  IN,OK|000-555 MN,NM|005-000 NV|055 500 MI|0550000 MD|0555000 CA|500 055 UT|500-005 TN|500-555 NJ|55 00000IL|55-0000 DC|55-00000CT|555 000 AK,IA,MI,MS,MP,SC,VT|555 0000MI,OH|555 500 FL|555000  IN|555-000 NM,PR|5550000 AZ,GA,WA|555-0000NY,NC,PA,TX,VA,WI','|')
,i WHERE v LIKE TRIM(REPLACE(REPLACE(LEFT(value,8),5,'[A-Z]'),0,'[0-9]'))

लाइन ब्रेक केवल पठनीयता के लिए हैं।

TRIMफ़ंक्शन का उपयोग करके SQL 2017 या उच्चतर तक सीमित । SQL 2016 (के लिए आवश्यक STRING_SPLIT), संभवतः RTRIM1 बाइट की कीमत पर प्रतिस्थापित करके है ।

$i$$v$

मैं मूल रूप से एक रिवर्स LIKEमैच कर रहा हूं : मैं प्रत्येक प्लेट के पैटर्न का विस्तार एक पूर्ण वाइल्डकार्ड पैटर्न से मिलान स्ट्रिंग की तरह करता हूं '[A-Z][0-9][0-9] [0-9][A-Z][A-Z]', फिर इनपुट मूल्य की तुलना करें, और मिलान वाले राज्यों (जो एक एकल क्षेत्र में संयुक्त है) को वापस करें।

लंबी स्ट्रिंग द्वारा GZIP'ing द्वारा कुछ और स्थान बचाने में सक्षम हो सकता है; मैं देखता हूँ कि अगर मदद करता है ...

Answer 3

पर्ल 5 (-p) , 165 बाइट्स

पोर्ट ऑफ @ अरनौलड के जावास्क्रिप्ट उत्तर, उसे भी अपटूडेट करते हैं।

y/0-8/9/;y/- A-Z/607/;$_=('xMiAZGAWaMIOhNvInxMNNmARKSKYLANDOrNMPrAKIAMIMSMPSCVtAsMdxScRiNhUtDcCtxFlxNYNCPATXVAWiInIlINOkNjCaTn'=~/[A-Z]*./g)[$_*3%47%30];s/../\U$& /g

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

Answer 4

चारकोल , 177 बाइट्स

§⪪”}∧▶⧴βμÞ∕×peＨ✂d‽n➙ＭR⁶↙↷◨5⁶;πＮM﹪θＷ:¡✂⧴O^(P↷kⅉχＲ⁺≔º↶∨§º⊞Ｂ⎚×p↔Ｌ\`²‖6'⁶⁹‴XüR⦃N4U⊙ＹＦ⁻ＺＭχLＳ⁸ＣX\hγ”;⌕⪪”{⊟“◨⦄»Ｕ>⌕⁻9“]±R▷Ｑ↔θü&$▷l⁹Ｚ⁼¡⁷×À›¶aA*βＺ³δ¡⟲²Y«№⌕TμN»πX·ＳΣ"εl⊙=3✂S?Ｋ”;⭆Ｓ⎇№αιA⎇Σι⁰ι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

                 Ｓ              Input string
                ⭆               Map over characters and join
                  ⎇             If
                     ι          Current character
                   №α           Is an uppercase letter
                      A         Then literal string `A`
                       ⎇        Else if
                         ι      Current character
                        Σ       Is non-zero
                          ⁰     Then digit `0`
                           ι    Else original character
        ⌕                       Find index in
          ”...”                 Compressed string of plates
         ⪪     ;                Split on semicolons
§                               Index into
  ”...”                         Compressed string of states
 ⪪     ;                        Split on semicolons
                                Implicitly print

सभी परीक्षण मामलों की कोशिश करो! लिंक कोड के वर्बोज़ संस्करण के लिए है। (कई मामलों को संसाधित करने के लिए थोड़ा अलग कोड आवश्यक है।)

अनजाने में @ अरनौलड के घोल का एक बंदरगाह केवल 121 बाइट्स पर बहुत छोटा है:

§⪪”}∧↨¦↑↧‴q⁰mπi3ＪE⪫³yＳ⪪c)？0≦·ê⊞Þ«ⅉ⁺&±<pAＲιaγ1A↑1L¶⟧/)Vº;Π∧,b✂≦¤ⅉαX⊕|″IνB[w∕¦Ｈ´Gγ§ν⟲^π!⪪¶ςbFü⊟»2”;﹪׳Ｉ⭆Ｓ⎇№αι⁷⎇⁼ι ⁰⎇⁼ι-⁶9⁴⁷

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। 30 द्वारा दूसरा मोडुलो को अनुक्रमण में सरणी में निहित किया गया है।

Answer 5

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

import re;f=lambda p,l='[A-Z]',r=re.sub,f=re.findall:f(l+'{2}',f(r(l,'1',r('[0-9]','0',p))+l+'+','0000AS0001IN00011IN000111INOK111000IN000 011SC000 111ARKSKYLANDOR000-000RI000-111MNNM001-000NV011 100MI0110000MD0111000CA100-001TN100-111NJ11-0000DC111 100FL111 000AKIAMIMSMPSCVT111-000NMPR1110000AZGAWA11 00000IL11-00000CT111 0000MIOH111-0000NYNCPATXVAWI1100 011UT000 0000NH')[0])

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

संख्याओं के साथ 0और अक्षरों को बदल देता है 1, फिर प्लेट के लिए स्ट्रिंग की खोज करता है और उसके बाद अक्षरों की एक स्ट्रिंग। फिर यह बस उस स्ट्रिंग में अक्षरों के हर गैर-अतिव्यापी जोड़ी को वापस करता है।

सबसे बाइट कुशल नहीं है, लेकिन एक अच्छी शुरुआत (शायद)।

मैं उन सूचनाओं के आधार पर चुनौतियों का आनंद लेता हूं जो सिर्फ उत्पन्न नहीं की जा सकतीं।

Answer 6

05AB1E , 176 बाइट्स

•1–ºʒÉQ÷¦PαN]lā?¨ìÎ₆™@ΔîÅλEŸʒ»ú<ŧa–½ã…ôkƒ¼½Ü%-ò∊aÍÙ•44374в4вε©gIgQi…'-Q'd'a„ðQ)VIεY®Nèè.V}Pë0].•=#îYn«ÈO4êʒIWj∊bÛˆ_ãZÑ"yŠótм‰иÔN–HδÖc°ìSJ9Ç\}ζÎäǝÑïÒ∞V.÷ζkÚ"¿Õнα£!ɪB…žä•#sÏ`2ô

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

•1–ºʒÉQ÷¦PαN]lā?¨ìÎ₆™@ΔîÅλEŸʒ»ú<ŧa–½ã…ôkƒ¼½Ü%-ò∊aÍÙ•44374в4в
                        push all patterns as base 4 integers (0="-", 1=number, 2=letter, 3=" ")

ε                       for each pattern
  ©                       copy it for later use inside another for for-loop
  gIgQi                   if it has the same length, as input
    …'-Q'd'a„ðQ)V           store ["'-Q", "d", "a", "ðQ"] in Y (05AB1E codes for "equals '-', is positive, is letter and equals ' ')
    Iε                      for each letter of input
      Y®Nèè                   get the 05AB1E code corresponding to the current index of the pattern
      .V                      run it
    }
    P                       check if all positions of that pattern were true
  ë                       else
    0                       push false
]

.•=#îYn«ÈO4êʒIWj∊bÛˆ_ãZÑ"yŠótм‰иÔN–HδÖc°ìSJ9Ç\}ζÎäǝÑïÒ∞V.÷ζkÚ"¿Õнα£!ɪB…žä•#
                        push list of states matching the pattern

sÏ                      get the entry of that list, that is true in the other list
`2ô                        split into groups of 2 letters and print