एक यूएस लाइसेंस प्लेट उत्पन्न करें

Question

इनपुट के रूप में निम्नलिखित में से एक दिया गया:

AK,AR,AS,AZ,CA,CT,DC,FL,GA,IL,IN,IA,KS,KY,LA,MD,MI,MN,MS,NV,NH,NJ,NM,NY,NC,ND,MP,OH,OK,OR,PA,PR,RI,SC,TN,TX,UT,VT,VA,WA,WI

(उद्धरण के साथ)

"AK","AR","AS","AZ","CA","CT","DC","FL","GA","IL","IN","IA","KS","KY","LA","MD","MI","MN","MS","NV","NH","NJ","NM","NY","NC","ND","MP","OH","OK","OR","PA","PR","RI","SC","TN","TX","UT","VT","VA","WA","WI"

इनपुट से मेल खाते प्रारूप की (समान रूप से) रैंडम लाइसेंस प्लेट जेनरेट और आउटपुट करें। यदि कई (अल्पविराम से अलग) प्रारूप हैं, तो (समान रूप से) यादृच्छिक प्रारूप का उपयोग करें:

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

जहां Aअपरकेस वर्णमाला में एक यादृच्छिक चरित्र का अर्थ है IOQऔर 0एक यादृच्छिक एकल अंक संख्या ( 0में 9) का मतलब है ।

विकिपीडिया से सभी जानकारी । ये (राज्य) वे सभी थे जिन्हें मैंने समझा और जिनके पास रूखी नियम नहीं थे।

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है!

Comments

वे दोनों इस मुद्दे को एक ही नंबर है, और पुलिस के लिए होता है क्या राज्य थाली से है देखने के लिए देखने के लिए कर सकते हैं @MagicOctopusUrn हे, उस के बारे में, एक ही प्रारूप के साथ अलग-अलग राज्यों नहीं एक दूसरे पर निगरानी रखने के है, इसलिए

— स्टीफन

प्रत्येक राज्य के लिए आकार संख्या स्थान भिन्न होता है। क्या हम 1) सभी राज्यों के लिए संयुक्त संख्या स्थान पर विचार करते हैं और उससे समान रूप से चुनते हैं (जो कि बड़ी संख्या वाले स्थानों के साथ अधिक भारी वजन वाले राज्यों में होगा)? या हम 2) पहले समान रूप से 50 राज्यों में से एक को चुनते हैं और फिर समान रूप से उस राज्य के नंबर स्थान से एक नंबर चुनते हैं (जो सभी राज्यों को समान रूप से भारित करेगा)?

— डिजिटल ट्रामा

माफ करना, मैंने इसे ठीक से नहीं पढ़ा। राज्य इनपुट है।

— डिजिटल ट्रामा

ठीक है, कई स्वरूपों वाले राज्यों के लिए समान प्रश्न, जैसे IN। क्या हम समान रूप से एक प्रारूप (000A, 000AA, 000AAA या AAA000 में से एक) चुनते हैं, फिर उस प्रारूप से एक संख्या चुनें (प्रत्येक प्रारूप समान रूप से भारित)। या क्या हम उस राज्य के लिए सभी प्रारूपों के लिए संख्या स्थान पर विचार करते हैं और उस संपूर्ण संख्या स्थान (बड़े प्रारूपों को अधिक भारित) से उठाते हैं?

— डिजिटल ट्रामा

मुझे लगता है कि आपने इनपुट की सूची से "एआर" और "ओआर" को छोड़ दिया, भले ही आप नीचे उनके प्लेट प्रारूपों का वर्णन करें।

— पेड़ नहीं

Answer 1

पर्ल 6 , 492 350 बाइट्स

{$_=('AKIAMSMPVT:7 3AS:4AZGAWA:74ARKSKYLANDOR:3 7CA:173CT:6-5DC:6-4FL:7 52IL:6 5IN:35,36,37,73MD:164MI:7 4,16 52,7 3MN:3-7NV:25-3NH:3 4NJ:52-7NM:3-7,7-3NYNCPATXVAWI:7-4OH:7 4OK:37PR:7-3RI:3-3SC:7 3,3 16TN:52-25UT:52 16'~~/$^a
[..]*?\:(<[\d]+[-\ ]>+)+%\,/)[0].pick;s:g/<[567]>/{[~]
(('A'..'Z')∖<I O Q>).pick xx($/-4)}/;S:g/\d/{[~] (^10).pick xx$/}/}

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

अपने पहले प्रयास के बाद मैं बहुत आगे था, मैंने कोड को नीचे गिराने का प्रयास नहीं किया। अब मेरे पास है।

लाइसेंस प्लेट पैटर्न के मेरे एन्कोडिंग में, संख्या 1-4 उस कई यादृच्छिक अंकों की एक रन को इंगित करता है, और नंबर 5-7 यादृच्छिक अनुमत अक्षरों को चलाने का संकेत देता है, संख्या की तुलना में कम चार।

Comments

क्या आप रिक्त स्थान को संभालते हैं?

— ज़ाचारि

आह, नहीं, वास्तव में, मैंने बाकी पाठों से पहले भी बहुत उत्साह से रिक्त स्थान निकाले। मैंने बारह अतिरिक्त बाइट्स के लिए रिक्त स्थान वापस रखा है।

— शॉन

Answer 2

पायथन 3, 861 821 819 714 678 674 670 662 661 658 596 591 561 555 551 536 बाइट्स।

-8 बाइट्स @ डस्टरेक्टिबल लेमन ( b=a+... और d=B...) के लिए धन्यवाद, -15 बाइट्स @ फेलिप नार्डी बतिस्ता (बेकार लंबोदा और चर) के लिए धन्यवाद

और चैट में हर किसी के लिए धन्यवाद जिसने इस गोल्फ की मदद की!

from random import*
C=choice
Z='000'
A='AAA'
B=A+'-0'+Z
a=A+' '+Z
b=A+'0'+Z
c=a[::-1]
d=B[1:]
print(C(''.join(C(['ABCDEFGHJKLMNPRSTUVWXYZ','0123456789',i]['A0'.find(i)])for i in([a]*5+[Z+'0',b,b,b]+[c]*6+['0'+A+Z,d,d+'0',A+' A00','AA 00'+Z,Z+'A,000AA,000AAA,'+A+Z,'0AA0'+Z,a+'0,0AA A00,'+a,Z+'-'+A,'00A-'+A,Z+' 0'+Z,'A00-'+A,Z+'-AAA,AAA-'+Z]+[B]*6+[a+'0',Z+A,B[:-1],Z+'-'+Z,a+','+c,'A00-00A','A00 0AA'])[[*zip('AIMMVAAGWAKKLNOCDCFIIMMMNNNNNNPTVWOOPRSTU','KASPTSZAARSYADRACTLLNDINVHJMYCAXAIHKRICNT')].index(tuple(input()))]).split(',')))

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

किसी भी गोल्फिंग सुझावों का स्वागत (और वांछित) है। और, कृपया, यदि आप कोई त्रुटि करते हैं, तो मुझे टिप्पणियों के माध्यम से बताएं!

Comments

क्या किसी आइटम को अजगर सूची में पिछले आइटम, या सूची में किसी अन्य आइटम को सेट करने का कोई तरीका है? की तरह, सेट IAकरने के लिए list[0]या ऐसा ही कुछ (मैं अजगर पता नहीं है)

— स्टीफन

नहीं। यह एक डिक्शनरी है, और मैंने डिक्शनरी को कोई नाम नहीं दिया है, इसलिए इसका संदर्भ देने का कोई तरीका नहीं है।

— ज़ाचारि

क्या बी असाइनमेंट नहीं हो सकता है b= a+"0"? d हो सकता है = B [1:]?

— विनाशकारी लेमन

ba+'0'जैसा कि मैंने लाइसेंस प्लेटों को खराब कर दिया है, ऐसा नहीं हो सकता ।

— ज़ाचारि

लैंबडा को हटाकर और सूची में पुनरावृत्ति जोड़कर 541 बाइट्स के नीचे 561

— फेलिप नारदी बतिस्ता

Answer 3

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

s=>(P=n=>parseInt(n,36),R=Math.random,g=F=>F?(' -'+(R()*10|0)+'ABCDEFGHJKLMNPRSTUVWXYZ'[R()*23|0])[F&3]+g(F>>2):'')(P('8cf,4q,8fz,ch6,8hq,xpb,8f3,8jj,xov,6i|ru|356|24f,8fy,xmn|8ji|8cf,ciy,8e2,xm2,ciz,ciy|8e7,xof,xmn,356,8e7,8dm,8cf|ca2,bjf,ca3'.split`,`[P('1k3600d2mha35h7bi00jc000o03000000809l002003n0h3032e0fh4g0h'[P(s)%159%131%70%58])].split`|`.sort(_=>R()-.5)[0]))

प्रारूपित और टिप्पणी की गई

निम्नलिखित कोड में, डेटा अनुभागों को काट दिया गया है। गुम भागों के साथ चिह्नित हैं (...)।

s => (                                  // given the state s
  P = n => parseInt(n, 36),             // P = base-36 parsing function
  R = Math.random,                      // R = random generator
  g = F =>                              // g = recursive function taking an encoded format F
    F ?                                 // if the format has not been yet fully processed:
      (                                 //   build a string consisting of:
        ' -' +                          //     0: space, 1: hyphen
        (R() * 10 | 0) +                //     2: a random digit
        'ABCD(...)YZ'[R() * 23 | 0]     //     3: a random uppercase letter (minus I, O, Q)
      )[F & 3] +                        //   pick the next character from this string
      g(F >> 2)                         //   recursive call, dropping the 2 consumed bits
    :                                   // else:
      ''                                //   stop recursion
  )(                                    // initial call to g():
    P(                                  //   base-36 decoding of a format picked from
      '8cf,4q,(...),ca3'.split`,`[      //     a list of binary encoded formats
        P(                              //       accessed through a base-36 decoded index
          '1k36(...)0h'[                //         picked from a lookup-table of 58 entries
            P(s) % 159 % 131 % 70 % 58  //           based on a hash of the state
          ]                             //         end of lookup-table access
        )                               //       end of lookup-table index decoding
      ].split`|`                        //     end of list access / split it on '|'
      .sort(_ => R() - .5)[0]           //     randomly pick a format from this list
    )                                   //   end of format decoding
  )                                     // end of call

डेमो

let f =

s=>(P=n=>parseInt(n,36),R=Math.random,g=F=>F?(' -'+(R()*10|0)+'ABCDEFGHJKLMNPRSTUVWXYZ'[R()*23|0])[F&3]+g(F>>2):'')(P('8cf,4q,8fz,ch6,8hq,xpb,8f3,8jj,xov,6i|ru|356|24f,8fy,xmn|8ji|8cf,ciy,8e2,xm2,ciz,ciy|8e7,xof,xmn,356,8e7,8dm,8cf|ca2,bjf,ca3'.split`,`[P('1k3600d2mha35h7bi00jc000o03000000809l002003n0h3032e0fh4g0h'[P(s)%159%131%70%58])].split`|`.sort(_=>R()-.5)[0]))

;[
  'AK','AR','AS','AZ','CA','CT','DC','FL','GA','IL','IN','IA','KS','KY',
  'LA','MD','MI','MN','MS','NV','NH','NJ','NM','NY','NC','ND','MP','OH',
  'OK','OR','PA','PR','RI','SC','TN','TX','UT','VT','VA','WA','WI'
]
.forEach(s => console.log(s + ' --> ' + f(s)))

Answer 4

टी-एसक्यूएल, 1104 1100 797 657 बाइट्स

DECLARE @ CHAR(8)SELECT @=STUFF(value,1,2,'')FROM STRING_SPLIT(CAST(DECOMPRESS(CAST('H4sIAAAAAAAEAEWPUQ6DMAiGr2JCwlM9BKnZ7LTV2E7n7n+QlRbYC3yl8PNDCyIOAOACKcVstCudRYkytPSthUZPUrqM6KhxqC+3ZKNbaSWlNCltNuEJuozzdekITXDygu6xshNkx2u3xJhqREmWGUQqTiDWYpBLGEGkrOgij47N21k1eKdLM3trI+mF+h2tMSJK441qM3nDnQzLx/D8V69guM3mblvkiP1Q/SPwTqbs1XD2zVztKwnbL7p3wV77AcxSbMHfAQAA'as XML).value('.','varbinary(max)'))AS varchar(max)),','),t WHERE s=LEFT(value,2)ORDER BY NEWID()WHILE CHARINDEX('&',@)>0SET @=STUFF(@,CHARINDEX('&',@),1,SUBSTRING('ABCDEFGHJKLMNPRSTUVWXYZ',CAST(1+23*RAND()AS INT),1))WHILE CHARINDEX('#',@)>0SET @=STUFF(@,CHARINDEX('#',@),1,CAST(10*RAND()AS INT))PRINT @

EDIT 1: 300 बाइट्स में परिवर्तित करके सहेजा VALUES()गया STRING_SPLIT()(केवल SQL 2016 और बाद में उपलब्ध)

EDIT 2: यहां वर्णित के रूप में GZIP संपीड़न का उपयोग करके एक और 140 बाइट्स को बचाया । हमने पहले ही खुद को SQL 2016 और बाद में प्रतिबंधित कर दिया है, इसलिए ये फ़ंक्शन उपलब्ध हैं।

इनपुट पूर्व मौजूदा तालिका के माध्यम से है टी कॉलम में राज्य कोड के साथ रों , हमारे आईओ मानकों के अनुसार ।

संपीड़ित स्ट्रिंग का विस्तार करने के बाद, यहां फॉर्मेट कोड, राज्यों की सुपर लंबी सूची के साथ छीन लिया गया है:

DECLARE @ CHAR(8)
SELECT @=STUFF(value,1,2,'')
FROM STRING_SPLIT('AK&&& ###,IA&&& ###,MS&&& ###,...
                         (long string continues)
                   ...,SC### #&&,TN&##-##&,UT&## #&&',','),t
WHERE s=LEFT(value,2)ORDER BY NEWID()

WHILE CHARINDEX('&',@)>0
    SET @=STUFF(@,CHARINDEX('&',@),1,
        SUBSTRING('ABCDEFGHJKLMNPRSTUVWXYZ',CAST(1+23*RAND()AS INT),1))

WHILE CHARINDEX('#',@)>0
    SET @=STUFF(@,CHARINDEX('#',@),1,
        CAST(10*RAND()AS INT))

PRINT @

इसलिए मैंने (राज्य, पैटर्न) के सभी संभावित जोड़े से मिलकर एक विशाल-स्मृति तालिका बनाई। ध्यान दें कि मैं पंक्तियों का संयोजन नहीं कर रहा हूं, प्रत्येक राज्य अलग है, और IN जैसे राज्यों में प्रत्येक पैटर्न के लिए 4 पंक्तियाँ होंगी।

जब मैं उस इन-मेमोरी टेबल को इनपुट टेबल में शामिल करता हूं, तो मैं क्रमबद्ध करता हूं NEWID(), जो ऑर्डर को यादृच्छिक करता है और चर के लिए एक यादृच्छिक मिलान पैटर्न देता है @।

मैं तब &एक यादृच्छिक पत्र के साथ प्रत्येक को प्रतिस्थापित करता हूं , और प्रत्येक #को एक यादृच्छिक अंक के साथ और परिणाम वापस करता हूं ।

Answer 5

> <> , 967 860 851 बाइट्स

</b:++d**d85-*i9*i2
v\+?\"00A AAA"
 /5:/
v\+?\"00000 AA"
 /4:/\
v\+?\x"000-AAA"
 /f:/
v\+?\>"AAA-000"
 /1:/
v\+ ?\"A00-00A"
v/cb:/\/"A000"
v\++?\xx"AA000"
v/88:/\x"000AAA"
v\+-?\ >"AAA000"
 /2f:/v\
v\*-?\xx"0000 AAA"
v/8c:/\x"00A AA0"
v\*-?\x>"000 AAA"
v/7c:/\"AA0 000"
v\*+?\"0000"
 /6b:/
v\*-?\"0000-AA"
 /5f:/
v\*-?\"0000AA0"
 /bc:/
v\+-?\"AAA-00A"
 /59:/
v\*+?\"000-AAA"
 /4a:/
v\*- ?\"000-000"
 /*a8:/
v\2+-?\"000AAA0"
 /*a8:/
v\9++?\"00000-AA"
 /*a8:/
v\5++?\"000-A00"
 /*a4:/
v\1+-?\"0000 000"
 /*a4:/
v\3+-?\"0000 AAA"
 /*a5:/
v\3++?\"AA0 00A"
 :63*+\:9a*4+-:aa*6++:73*+
 /*+9:/
v\***?\"000 AAA"
 8*-*$\::9a*-:4
 /7*ae/
v\++*?\"0000AAA"
 :4a*3\:aa*-:cb++:ca*4++:a7++:b+
v/**++/"0000-AAA"
v\***?/"AAA 000"
<ov?="A":v?="0":;?=1l
~!/0\v[0<
 l<1x/?=]!5
 +*2_/?= 1l
 -8::/*(~!*d2$**-2:-6:
^    >?!^"A"+o]
]~</0\v[0<
 l <1x/?=4
 + *2_<v?=1l
^n^?)9:<

इसे ऑनलाइन आज़माएं , या इसे मछली के खेल के मैदान में देखें !

इस कोड के दो भाग हैं: पैटर्न से राज्य का मिलान, फिर यादृच्छिक वर्णों के साथ पैटर्न की जगह। इन चीजों में से न तो आसान है> <>।

सबसे पहले, हम दो वर्णों में पढ़ते हैं, और 2 c ₁ - 9  c ₂ + 533 की गणना करते हैं  , जहाँ c ₁ और b ₂दो चरित्र कोड हैं। 2 और 9 को इसलिए चुना गया कि सूत्र प्रत्येक राज्य को एक अद्वितीय मूल्य देता है, और 533 की ऑफसेट को इन मानों की संख्या को अधिकतम करने के लिए चुना गया था जिन्हें केवल 3> <> निर्देशों का उपयोग करके बनाया जा सकता है - यह 28 को समाप्त किया जा रहा है उनमें से 41। हम तब कोड के माध्यम से मछली के जिग-जैगिंग को नीचे भेजते हैं जब तक कि उसे सही मूल्य नहीं मिल जाता है, जिस बिंदु पर वह ज़िग-ज़ैग से बच जाता है, उपयुक्त पैटर्न को पढ़ता है और सबसे बाईं ओर के कॉलम में फास्ट स्ट्रीम में भाग 2 में प्रवेश करता है। कुछ राज्यों, विशेष रूप से कई पैटर्न की पसंद वाले लोगों को कुछ विशेष विचार की आवश्यकता थी, लेकिन मैं कुछ बाइट्स को बचाने के लिए कोड के कुछ टुकड़ों का पुन: उपयोग करने में कामयाब रहा।

अगला, उर्फ ​​भाग 2, हमें क्रमशः "A" s और "0" s को यादृच्छिक अक्षरों और संख्याओं से बदलना होगा। > <> में एकमात्र यादृच्छिक कमांड है x, जो मछली की दिशा को यादृच्छिक रूप से ऊपर, नीचे, बाएं और दाएं से सेट करता है - 10 अंकों या 23 अक्षरों में से कुछ समान रूप से चुनने के लिए अनुकूल नहीं है। आइए संख्याओं को देखें कि मछली कैसे करती है:

]~</0\v[0<
 l <1x<v?=4
 l 1=_?\2*+
^n^?)9:<

मछली ऊपर दाईं ओर से प्रवेश करती है। मछली एक खाली स्टैक स्थापित करती है - 0[- फिर बेतरतीब ढंग से धक्का देती है 1या 0समान संभावना के साथ जब तक स्टैक की लंबाई 4:

   /0\v
 l <1x<v?=4
     _

यह चार 1एस और 0एस को एक साथ जोड़ती है जैसे कि वे द्विआधारी अंक थे - l1=?\2*+- 0 से 15. तक एक संख्या दे रहे हैं। यदि परिणाम 9 से अधिक है, तो यह बस किए गए सभी कार्यों को त्याग देता है और फिर से कोशिश करता है; अन्यथा, यह संख्या को प्रिंट करता है और जारी रखता है:

]~<   v[0<
     x<

^n^?)9:<

यादृच्छिक अक्षरों को बनाना एक समान है, सिवाय इसके कि हम यह भी जाँचें कि परिणाम "I", "O" या "Q" के साथ नहीं है ::8-:6-:2-**।

Answer 6

गणितज्ञ, 635 507 470 बाइट्स

p=RandomChoice;a_±b_:=a<>b;r=""±Characters@"ABCDEFGHJKLMNPRSTUVWXYZ"~p~#&;j=""±ToString/@0~Range~9~p~#&;m=r@3;o=j@3;x=r@2;u=j@2;z=r@1;t=j@1;k=z±u±"-";w=m±" ";AS=y=j@4;AZ=GA=WA=m±y;CT=x±"-"±j@5;DC=x±"-"±y;FL=w±z±u;IL=x±" "±j@5;IN=p@{o±z,o±x,OK=o±m,s=m±o};CA=t±s;MD=t±x±y;MI=p@{OH=w±y,t±x±" "±z±u,AK=IA=MS=MP=VT=w±o};NV=u±z±"-"±o;NH=o±" "±y;NM=p@{MN=o±"-"±m,PR=m±"-"±o};NY=NC=PA=TX=VA=WI=m±"-"±y;RI=o±"-"±j@3;SC=p@{AR=KS=KY=LA=ND=OR=o±" "±m,VT};NJ=k±m;TN=k±u±z;UT=k±t±x;#&

-165 बाइट्स @ जुंगहवनमिन से

इनपुट फॉर्म

[NV]

Comments

मैंने वर्णमाला का उपयोग नहीं किया [] क्योंकि हमें 3 अक्षर (IOQ) को बाहर करना है

— J42161217

वूप्स, मेरे पिछले एक काम नहीं किया। वर्किंग वर्जन: 507 बाइट्स: pastebin.com/4YkkQrC

— JungHwan Min

470 बाइट्स (CP-1252) का उपयोग करके \[PlusMinus]: pastebin.com/cGHvSJRi

— जंगहवान मिन

Answer 7

PHP, 609 बाइट्स

<?$k='9 3';$l='3 9';$m='9-4';$f=[AK=>$k,IA=>$k,MS=>$k,MP=>$k,VT=>$k,'AS'=>4,AZ=>94,GA=>94,WA=>94,AR=>$l,KS=>$l,KY=>$l,LA=>$l,ND=>$l,'OR'=>$l,CA=>193,CT=>'8-5',DC=>'8-4',FL=>'9 72',IL=>'8 5',IN=>'37X38X39X93',MD=>184,MI=>'9 31X18 72X9 3',MN=>'3-9',NV=>'27-3',NH=>'3 4',NJ=>'72-9',NM=>'3-9X9-3',NY=>$m,NC=>$m,PA=>$m,TX=>$m,VA=>$m,WI=>$m,OH=>"$k1",OK=>39,PR=>'9-3',RI=>'3-3',SC=>"$kX3 18",TN=>'72-27',UT=>'72 18'];$a=str_split(ABCDEFGHJKLMNPRSTUVWXYZ);$n=range(0,9);$p=explode(X,$f[$argv[1]]);shuffle($p);for(;$c=$p[0][$i++];){if($c<1)echo$c;else for($j=0;$j<$c%6;$j++){echo$c>5?$a[rand(0,22)]:$n[rand(0,9)];}}

मुख्य विचार लाइसेंस प्लेट पैटर्न को अंकों के साथ सांकेतिक शब्दों में बदलना है जो बताता है कि अंक या पत्र के कितने दोहराव का पालन किया जाता है। 1 से 5 अंकों की संख्या को संदर्भित करते हैं, जबकि 7, 8 और 9 क्रमशः 1, 2 या 3 अक्षरों को संदर्भित करते हैं। एक एक्स द्वारा कई पैटर्न अलग किए जाते हैं, रिक्त स्थान और डैश को इस प्रकार रखा जाता है। राज्य लुकअप एक साधारण सरणी कुंजी लुकअप है, अंतरिक्ष को बचाने के लिए निरर्थक तार चर में डाल दिए जाते हैं।

Ungolfed:

<?php
$f=[
    AK=>'9 3',
    IA=>'9 3',
    MS=>'9 3',
    MP=>'9 3', 
    VT=>'9 3',
    'AS'=>4,
    AZ=>94,
    GA=>94,
    WA=>94,
    AR=>'3 9',
    KS=>'3 9',
    KY=>'3 9',
    LA=>'3 9',
    ND=>'3 9',
    'OR'=>'3 9',
    CA=>193,
    CT=>'8-5',
    DC=>'8-4',
    FL=>'9 72',
    IL=>'8 5',
    IN=>'37X38X39X93',
    MD=>184,
    MI=>'9 31X18 72X9 3',
    MN=>'3-9',
    NV=>'27-3',
    NH=>'3 4',
    NJ=>'72-9',
    NM=>'3-9X9-3',
    NY=>'9-4',
    NC=>'9-4',
    PA=>'9-4',
    TX=>'9-4',
    VA=>'9-4',
    WI=>'9-4',
    OH=>'9 31',
    OK=>39,
    PR=>'9-3',
    RI=>'3-3',
    SC=>'9 3X3 18',
    TN=>'72-27',
    UT=>'72 18'
];
$a=str_split(ABCDEFGHJKLMNPRSTUVWXYZ);
$n=range(0,9);
$p=explode('X',$f[$argv[1]]);
shuffle($p);
for ($i = 0; $i < strlen($p[0]); $i++) {
    $c=$p[0][$i];
    if ($c < 1)
        echo $c;
    else {
        for ($j = 0; $j < $c % 6; $j++){
            echo $c > 5 ? $a[rand(0,22)] : $n[rand(0,9)];
        }
    }
}

Answer 8

PHP ( फ़ार ), 495 बाइट्स

बाइनरी फ़ार फ़ाइल को यहां डाउनलोड किया जा सकता है और इसके साथ चलाया जा सकता है php uslic.phar <state code>।

Phar को जनरेट करने के लिए उपयोग किया जाने वाला आधार कोड निम्न है (820 बाइट्स):

<?$f=[AK=>'AAA 111',IA=>'AAA 111',MS=>'AAA 111',MP=>'AAA 111',VT=>'AAA 111','AS'=>'1111',AZ=>'AAA1111',GA=>'AAA1111',WA=>AAA1111,AR=>'111 AAA',KS=>'111 AAA',KY=>'111 AAA',LA=>'111 AAA',ND=>'111 AAA','OR'=>'111 AAA',CA=>'1AAA111',CT=>'AA-11111',DC=>'AA-1111',FL=>'AAA A11',IL=>'AA 11111',IN=>'111AX111AAX111AAAXAAA111',MD=>'1AA1111',MI=>'AAA 1111X1AA A11XAAA 111',MN=>'111-AAA',NV=>'11A-111',NH=>'111 1111',NJ=>'A11-AAA',NM=>'111-AAAXAAA-111',NY=>'AAA-1111',NC=>'AAA-1111',PA=>'AAA-1111',TX=>'AAA-1111',VA=>'AAA-1111',WI=>'AAA-1111',OH=>'AAA 1111',OK=>'111AAA',PR=>'AAA-111',RI=>'111-111',SC=>'AAA 111X111 1AA',TN=>'A11-11A',UT=>'A11 1AA'];$a=str_split(ABCDEFGHJKLMNPQRSTUVWXYZ);$n=range(0,9);$p=explode(X,$f[$argv[1]]);shuffle($p);for(;$i<strlen($p[0]);){$c=$p[0][$i++];echo$c==A?$a[rand(0,22)]:($c>0?$n[rand(0,9)]:$c);}

यदि आप उस कोड से फ़ार स्वयं उत्पन्न करना चाहते हैं, तो आपको निम्नलिखित कार्य करने होंगे:

<?php
$phar = new Phar('uslic.phar', 0, 'u');
$phar->setSignatureAlgorithm(Phar::MD5);
$phar->addFile('s');
$phar['s']->compress(Phar::GZ);
$phar->setStub('<?include"phar://u/s";__HALT_COMPILER();');

दिलचस्प रूप से पर्याप्त है, यह अधिक गोल्फ संस्करण से बेहतर संपीड़ित करता है ।

फ़ाइल का हेक्सडंप है:

3C 3F 69 6E 63 6C 75 64 65 22 70 68 61 72 3A 2F 
2F 75 2F 73 22 3B 5F 5F 48 41 4C 54 5F 43 4F 4D 
50 49 4C 45 52 28 29 3B 20 3F 3E 0D 0A 30 00 00 
00 01 00 00 00 11 00 00 00 01 00 01 00 00 00 75 
00 00 00 00 01 00 00 00 73 34 03 00 00 26 C8 A9 
59 76 01 00 00 E3 82 AE C9 B6 11 00 00 00 00 00
00 55 90 5D 6F 82 30 14 86 FF 8A 17 4D 0A B1 26 
E2 9D 43 34 1D 4C 45 04 19 20 A2 84 2C 04 41 4D 
0C 12 74 CB 92 65 FF 7D A5 AD A3 DC 34 7D CE C7 
FB 9E 73 26 33 50 68 31 B6 B4 29 C4 18 F7 14 45 
81 C8 C4 22 D9 7E 87 5C 91 C2 40 24 88 7D 48 58 
A1 80 0F 2C C5 68 81 45 DA 11 E2 80 B0 C7 5A 7A 
24 00 91 E5 77 68 2F D2 1A 8B E4 18 22 C1 8D 07 
45 D6 69 2D F3 20 C4 C6 1C 28 CC DE D0 5B 84 68 
BE E6 3B 60 BA 3B A3 1E 2F 35 1D A6 8A A3 E6 E1
2F 8E 9E C2 B6 C1 6C 58 B1 6D B6 D7 50 22 85 49 
46 ED E9 B8 D6 80 CD 1F 52 A2 53 10 5A F2 E9 99    
92 B3 6A 94 FE 4B ED B6 B1 91 E3 2D 7B E6 C6 D7 
70 F4 0E BA B8 83 41 D4 C1 B0 9B DD 99 1D DC 2C
85 3D 08 5A FC 06 CD 2C AE D7 96 42 E4 99 7C 32
4A BE DE F6 45 74 99 A6 23 70 F8 2E 44 01 A2 6D
C0 88 E6 12 15 A4 DA FD 51 7F DC AB EB E5 21 E1 
57 DD 78 9B 2F 96 2B 6B 6D 3B EE BB E7 07 DB 70
17 ED 0F B2 0A 4A AD 4E CB 53 2E 0D D1 98 50 A5 
E5 DF D5 F5 76 CC A5 08 81 22 06 69 7D FA 8A 95 
24 91 D5 FB F9 B3 28 AE B9 04 2A 59 2D 6E B5 A4 
82 CB 84 18 5C F3 92 84 E2 21 A9 90 7F 40 A6 D1 
7F 0C 2E FD 7E A2 E6 D9 F9 46 42 1A 9E 81 34 26 
2E 47 62 32 1A C9 C9 8B 04 B2 E9 70 06 CA 67 70 
4C 62 20 93 D5 DF 3F A0 DB 74 9C 07 ED A5 F7 4D 
BA 32 97 A2 E7 9C 83 01 00 00 00 47 42 4D 42 

Answer 9

क्लोजर, 502 501 बाइट्स

#(apply str(for[E[repeatedly]c(rand-nth(cond('#{AK IA MS MP VT}%)["D 3"]('#{AR KS KY LA ND OR}%)["3 D"]('#{AZ GA WA}%)["D4"]1(case % AS["4"]CA["1D3"]CT["C-5"]DC["C-3"]FL["D B1"]IL["C 4"]IN["3B""3C""3D""D2"]MD["1C3"]MI["D 4""1C B2""D 2"]MN["3-C"]NV["2B-2"]NH["3 3"]NJ["B2-C"]NM["3-D""D-2"]OH["D 3"]OK["3C"]PR["D-2"]RI["3-2"]SC["D 3""3 1B"]TN["B2-2"]UT["B2 1B"]["D-4"])))r(cond((set"BCD")c)(E(-(int c)65)(fn[](rand-nth"ABCDEFGHJKLMNPRSTUVWXYZ")))((set"1234")c)(E(-(int c)48)(fn[](rand-int 10)))1[c])]r))

इनपुट तर्क एक प्रतीक है , न कि एक स्ट्रिंग। यह मुझे कई दोहरे उद्धरणों से बचने देता है। B- Dएनकोड पुनरावृत्ति A- AAA, 1- 4एनकोड पुनरावृत्ति 0- 0000।

Answer 10

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

import re,random
lambda s,R=range,C=random.choice:re.sub('\d',lambda c:''.join(C(['0123456789','ABCDEFGHJKLMNPRSTUVWXYZ'][c.group()>'4'])for _ in R(int(c.group())%5+1)),C("063;6-3;072;3;7 2,2 06;6-4;51-15;2-7,7-2;7 2;;7 3;;6 4;2 7;2 7;2-2;25,26,27,72;2 7;;7 3,06 51,7 2;7 2;73;;2 3;;7 51;;73;7 2;2 7;;27;2 7;;7 2;7-2;;73;;51-7;;51 06;;2-7;15-2;7 2;;7-3".split(";")["MDCASCTNMSOHILARINDMIAZNHFLWAKSOKYMPRGANJUTMNVTOR".find(s)].split(",")))

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

पठनीय संस्करण: इसे ऑनलाइन आज़माएं!

ध्यान दें कि statesस्ट्रिंग केवल 49 अक्षर लंबा है। मैंने ओवरलैपिंग लेटर्स को जितना संभव हो सके, तह किया ( MD→ DC→ CA→ AS→ SC…) और छोड़ा गया NY, NC, PA, TX, VA, WIजो इस तरह से सभी मैप में आया -1।

की सूची में codes, 12345इसका मतलब है कि कई अंक और 678माध्य (many 5) कई अक्षर हैं।

Answer 11

सी (जीसीसी) , 473 469 बाइट्स

-4 बाइट्स के लिए सीलिंगकैट के लिए धन्यवाद।

पहली बार का प्रयास। मुझे लगता है कि स्ट्रिंग्स को काफी हद तक छोटा करने का एक तरीका है।

n,c,d,i;f(char*s){n=0;for(s=strstr("AKnIAnMSnMPnVTnAS`AZrGArWArARfKSfKYfLAfNDfORfCAlCTtDCsFLpILmINbcdqMDkMInojMNhNViNHgNJuNMhxNYyNCyPAyTXyVAyWIyOHoOKdPRxRIaSCoeTNvUTw",s)+2;s[n]>90;n++);for(s="4    3-3  3A   3B   3C   3 1B 3 C  3 4  3-C  2A-3 1B A21B4  1BA3 B 5  C 3  C 4  C A2 C3   C4   B-4  B-5  A2-C A2-2AA2 1BC-3  C-4  "+(s[rand()%n]-96)*5,n=5;d=c=*s++,n--;)for(c>57?i=c-64,c=65:c>47?i=c-48,c=48:(i=1);i--;putchar(d))while(i&&index("IOQ",d=rand()%(c>57?26:10)+c));}

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

Comments

@ceilingcat अच्छा है, चीयर्स!

— गैस्ट्रोपनर