Wygeneruj amerykańską tablicę rejestracyjną

16

Biorąc pod uwagę jeden z następujących danych wejściowych:

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

(z cytatami)

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

Wygeneruj i wyprowadź (jednolicie) losową tablicę rejestracyjną formatu zgodnego z danymi wejściowymi. Jeśli istnieje wiele formatów (oddzielonych przecinkami), użyj (równomiernie) formatu losowego:

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

Gdzie Aoznacza losowy znak wielkimi literami minus IOQi 0oznacza losową liczbę jednocyfrową ( 0do 9).

Wszystkie informacje z Wikipedii . Te (stany) były wszystkie te, które zrozumiałem i które nie miały dziwnych zasad.

To jest , więc wygrywa najkrótsza odpowiedź w bajtach!

Stephen
źródło
2
@MagicOctopusUrn heh, o tym, różne stany o tym samym formacie nie trzymają się nawzajem, więc mogą wydać ten sam numer, a gliniarze będą musieli sprawdzić, z jakiego stanu pochodzi tabliczka
Stephen
1
Przestrzeń liczbowa wielkości dla każdego stanu jest różna. Czy 1) bierzemy pod uwagę połączoną przestrzeń liczbową dla wszystkich stanów i jednolicie wybieramy z niej (która będzie bardziej obciążać stany przy większej liczbie odstępów liczbowych)? Czy też 2) najpierw jednolicie wybieramy jeden z 50 stanów, a następnie jednolicie wybieramy liczbę z przestrzeni liczbowej tego stanu (która będzie ważyć wszystkie stany jednakowo)?
Cyfrowa trauma
1
Och, przepraszam, nie przeczytałem go poprawnie. Stan jest wprowadzany.
Digital Trauma
1
Ok, podobne pytanie do stanów, które mają wiele formatów, np IN. Czy jednolicie wybieramy format (jeden z 000A, 000AA, 000AAA lub AAA000), a następnie wybieramy liczbę z tego formatu (każdy format ważony równo). Czy też rozważamy przestrzeń liczbową dla wszystkich formatów dla tego stanu i wybieramy z całej tej przestrzeni liczbowej (większe formaty ważone większe)?
Digital Trauma
2
Myślę, że pominąłeś „AR” i „OR” z listy danych wejściowych, mimo że poniżej opisujesz ich formaty płyt.
Nie drzewo,

Odpowiedzi:

3

Perl 6 , 492 350 bajtów

{$_=('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$/}/}

Wypróbuj online!

Byłem tak daleko przed moją pierwszą próbą, że nie poczyniłem wielkiego wysiłku, aby obniżyć kod. Teraz mam.

W moim kodowaniu wzorów tablic rejestracyjnych cyfry 1-4 oznaczają serię tak wielu losowych cyfr, a cyfry 5-7 wskazują serię losowo dozwolonych liter o długości cztery mniejszej niż liczba.

Sean
źródło
Czy zajmujesz się spacjami?
Zacharý
Ach, nie, wcześniej zbyt entuzjastycznie usuwałem spacje z reszty tekstu. Odłożyłem spacje na dwanaście dodatkowych bajtów.
Sean
6

Python3, 861 821 819 714 678 674 670 662 661 658 596 591 561 555 551 536 bajtów.

-8 bajtów dzięki @DestructibleLemon ( b=a+... i d=B...), -15 bajtów dzięki @Felipe Nardi Batista (bezużyteczna lambda i zmienna)

I dzięki wszystkim na czacie, którzy pomogli w grze w golfa!

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(',')))

Wypróbuj online

Wszelkie sugestie dotyczące gry w golfa są mile widziane (i potrzebne). I proszę, jeśli zauważysz jakieś błędy, po prostu powiedz mi za pomocą komentarzy!

Zacharý
źródło
Czy jest jakiś sposób, aby ustawić element na liście python do poprzedniego elementu lub innego elementu na liście? Like, set IAto list[0]lub coś w tym stylu (nie znam Pythona)
Stephen
Nie. To słownik i nie przypisałem nazwy do słownika, więc nie ma sposobu, aby się do niego odwoływać.
Zacharý
1
nie może być przypisanie b b= a+"0"? d może być = B [1:]?
Destructible Lemon
bnie może być a+'0', bo spieprzyłem tablice rejestracyjne.
Zacharý
1
561 do 541 bajtów poprzez usunięcie lambda i dodanie powtórzeń do list
Felipe Nardi Batista
6

JavaScript (ES6), 374 368 bajtów

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

Sformatowane i skomentowane

W poniższym kodzie sekcje danych zostały obcięte. Brakujące części są oznaczone symbolem (...).

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

Próbny

Arnauld
źródło
5

T-SQL, 1104 1100 797 657 bajtów

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 @

EDYCJA 1: Zapisano ponad 300 bajtów, zmieniając VALUES() na STRING_SPLIT()(dostępne tylko w SQL 2016 i nowszych)

EDYCJA 2: Zaoszczędzono kolejne 140 bajtów, używając kompresji GZIP jak opisano tutaj . Już ograniczyliśmy się do SQL 2016 i późniejszych, więc te funkcje są dostępne.

Wprowadzanie odbywa się za pomocą istniejącej tabeli t z kodem stanu w kolumnie s , zgodnie z naszymi standardami we / wy .

Po rozwinięciu skompresowanego ciągu, oto sformatowany kod, z wycinaną bardzo długą listą stanów:

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 @

Stworzyłem więc ogromną tabelę w pamięci składającą się ze wszystkich możliwych par (stan, wzorzec). Zauważ, że nie łączę wierszy, każdy stan jest osobny, a stany takie jak IN będą miały 4 wiersze, po jednym dla każdego wzorca.

Kiedy dołączam tę tabelę w pamięci do tabeli wejściowej, sortuję według NEWID(), co losuje kolejność i zwraca losowy wzorzec dopasowania do zmiennej@ .

Następnie po prostu zastępuję każdą &losową literą, a każdą #losową cyfrą i zwracam wynik.

BradC
źródło
4

> <> , 967 860 851 bajtów

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

Wypróbuj online lub obejrzyj na placu zabaw dla ryb !

Ten kod składa się z dwóch części: dopasowanie stanu do wzorca, a następnie zastąpienie wzorca losowymi znakami. Żadna z tych rzeczy nie jest łatwa w> <>.

Przede wszystkim czytamy dwoma znakami i obliczamy 2  c 1 - 9  c 2 + 533, gdzie c 1 i c 2to dwuznakowe kody. 2 i 9 zostały wybrane tak, że formuła nadaje każdemu stanowi unikalną wartość, a przesunięcie 533 zostało wybrane, aby zmaksymalizować liczbę tych wartości, które można wykonać za pomocą tylko 3 instrukcji <> - ostatecznie wyszło 28 z 41 z nich. Następnie wysyłamy rybę zygzakowatą w dół przez kod, aż znajdzie odpowiednią wartość, w którym to momencie ucieka zygzakowatym, odczytuje odpowiedni wzorzec i wchodzi do szybkiego strumienia w lewej kolumnie do części 2. Niektóre z stany, szczególnie te z wyborem wielu wzorców, wymagały szczególnej uwagi, ale udało mi się ponownie użyć niektórych fragmentów kodu, aby zaoszczędzić kilka bajtów.

Następnie, aka Część 2, musimy zastąpić litery „A” i „0” odpowiednio losowymi literami i cyframi. Jedynym losowym poleceniem w> <> jest to x, że losowo ustawia kierunek ryby z góry, dołu, lewej i prawej - nie sprzyja wybieraniu czegoś jednorodnie z 10 cyfr lub 23 liter. Spójrzmy na bit liczb, aby zobaczyć, jak robi to ryba:

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

Ryba wchodzi od prawego górnego rogu. Ryba ustawia pusty stos - 0[- następnie losowo przepycha 1lub 0z jednakowym prawdopodobieństwem, aż stos osiągnie długość 4:

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

Następnie łączy cztery 1si 0razem, jak gdyby były cyframi binarnymi - l1=?\2*+- dając liczbę od 0 do 15. Jeśli wynik jest większy niż 9, odrzuca całą pracę, którą właśnie wykonał i próbuje ponownie; w przeciwnym razie drukuje numer i kontynuuje:

]~<   v[0<
     x<

^n^?)9:<

Tworzenie losowych liter jest prawie takie samo, z tym wyjątkiem, że sprawdzamy również, czy wynikiem nie jest „I”, „O” lub „Q” z ::8-:6-:2-**.

Nie drzewo
źródło
3

Mathematica, 635 507 470 bajtów

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 bajtów od @JungHwanMin

formularz wejściowy

[NV]

J42161217
źródło
1
Nie użyłem Alphabet [], ponieważ musimy wykluczyć 3 litery (IOQ)
J42161217
Ups, mój ostatni nie działał. Wersja robocza: 507 bajtów: pastebin.com/4YkkkQrC
JungHwan Min
470 bajtów (CP-1252) przy użyciu \[PlusMinus]: pastebin.com/cGHvSJRi
JungHwan Min
1

PHP, 609 bajtów

<?$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)];}}

Główną ideą jest zakodowanie wzoru tablicy rejestracyjnej za pomocą cyfr wskazujących, ile powtórzeń cyfry lub litery następuje. Od 1 do 5 odnoszą się do liczby cyfr, a 7, 8 i 9 odnoszą się odpowiednio do 1, 2 lub 3 liter. Wiele wzorów jest oddzielonych znakiem X, spacje i myślniki są zachowywane bez zmian. Wyszukiwanie stanu to proste wyszukiwanie klucza tablicy, nadmiarowe ciągi znaków są umieszczane w zmiennych w celu zaoszczędzenia miejsca.

Nie golfowany:

<?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)];
        }
    }
}
YetiCGN
źródło
1

PHP ( Phar ), 495 bajtów

Binarny plik Phar można pobrać tutaj i uruchomić gophp uslic.phar <state code> .

Kod podstawowy użyty do wygenerowania Phara jest następujący (820 bajtów):

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

Jeśli chcesz sam wygenerować Phara z tego kodu, musisz wykonać następujące czynności:

<?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();');

Co ciekawe, kompresuje się lepiej niż wersja bardziej golfowa .

Zrzut heksowy pliku to:

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 
YetiCGN
źródło
1

Clojure, 502 501 bajtów

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

Argument wejściowy jest symbolem , a nie ciągiem. Pozwoliło mi to uniknąć wielu podwójnych cudzysłowów. B- Dkodowanie powtórzeń A- AAA, 1- 4kodowanie powtórzeń 0- 0000.

NikoNyrh
źródło
1

Python 2 , 438 bajtów

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(",")))

Wypróbuj online!

Wersja do odczytu: Wypróbuj online!

Zwróć uwagę, że statesciąg ma tylko 49 liter. Złożyłem nakładające się litery w jak najwięcej ( MDDCCAASSC…) i pominąłem NY, NC, PA, TX, VA, WIwszystkie, które w ten sposób odwzorowują -1.

Na liście codes, 12345oznacza to, że wiele cyfr i 678średnie (that-5) wiele listów.

Lynn
źródło
1

C (gcc) , 473 469 bajtów

Dzięki pułapowi cat na 4 bajty.

Pierwsza słaba próba. Podejrzewam, że istnieje sposób na znaczne skrócenie strun.

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

Wypróbuj online!

gastropner
źródło
@ceilingcat Ładne, na zdrowie!
gastropner