Francuskie tablice rejestracyjne

41

Piaskownica

Francuskie tablice rejestracyjne

Francuskie tablice rejestracyjne występują w kolejności sekwencyjnej, według określonego wzoru cyfr i liter:AB-012-CD

Wyzwanie

Napisz program lub funkcję, która dla danego numeru generuje odpowiedni francuski numer tablicy rejestracyjnej . Twój program nie powinien obsługiwać żadnego specjalnego przypadku określonego na połączonej stronie. Powinien być w stanie wygenerować pełne 26*26*1000*26*26 => 456 976 000możliwe tablice lub, o ile Twój język może to obsługiwać.

System numeracji wygląda następująco:

  • AA-000-AA do AA-999-AA (liczby ewoluują najpierw);
  • AA-000-AB do AA-999-AZ (wtedy ostatnia litera po prawej stronie);
  • AA-000-BA do AA-999-ZZ (wtedy pierwsza litera po prawej);
  • AB-000-AA do AZ-999-ZZ (następnie ostatnia litera po lewej);
  • BA-000-AA do ZZ-999-ZZ (następnie pierwsza litera po lewej).

Wejście

  • Indeks numeru rejestracyjnego jako liczba całkowita

Wydajność

  • Odpowiedni francuski numer rejestracyjny

Dodatkowe informacje

  • Litery muszą być pisane wielkimi literami
  • Możesz użyć indeksowania opartego na 0 i na 1 do wygenerowania płytek (co oznacza, że ​​AA-000-AA może odpowiadać 0lub 1, zakładając, że wszystkie pozostałe przypadki testowe korzystają z tego samego indeksowania.

To jest golf golfowy , wygrywa najkrótsza odpowiedź w każdym języku!

Przypadki testowe (indeksowanie 0)

          0 -> AA-000-AA
          1 -> AA-001-AA
        999 -> AA-999-AA
       1000 -> AA-000-AB
    675 999 -> AA-999-ZZ
    676 000 -> AB-000-AA
456 975 999 -> ZZ-999-ZZ
Elcan
źródło
2
Oto kilka innych wymagań, bezpośrednio z Wikipedii, jeśli chcesz stworzyć trudniejszą odmianę: „Ta liczba wyklucza trzy nieużywane litery: I, O i U, ponieważ można je pomylić z odpowiednio 1, 0 i V. Wyklucza również kombinację SS, ponieważ przypomina pierwszą organizację nazistowską i WW w pierwszej grupie listów, ponieważ wskazuje na tymczasową tabliczkę. ”
Eric Duminil,
4
@EricDuminil Celowo go wykluczyłem, ponieważ po prostu dodało nieuzasadnione ograniczenia dla wyzwania. Ale to prawda, że ​​może to być interesujące, ale nawet przy „punktach bonusowych” wątpię, czy warto wdrożyć te zasady
Elcan

Odpowiedzi:

17

Pure Bash (bez zewnętrznych narzędzi), 64

  • 2 bajty zapisane dzięki @NahuelFouilleul
x={A..Z}
eval f=($x$x-%03d-$x$x)
printf ${f[$1/1000]} $[$1%1000]

Wypróbuj online! - przejście przez 7 przypadków testowych zajmuje około 10 sekund.

  • Wiersz nr 1 to proste przypisanie ciągu do zmiennej
  • Wiersz # 2 jest rozwinięciem nawiasu klamrowego do budowy tablicy ciągów formatu printf, po jednym dla wszystkich 456,976 możliwych kombinacji liter, z cyframi jeszcze nieokreślonymi. Jest evalto wymagane do zapewnienia, że ​​zmienna ekspansja (x) nastąpi przed ekspansją nawiasu.
  • Wiersz # 3 indeksuje tablicę, aby uzyskać odpowiedni ciąg formatu, i bierze część cyfr jako parametr.
Cyfrowa trauma
źródło
1
-2 bajty
Nahuel Fouilleul
13

Perl 5 (-ap), 47 bajtów

$_=AAAA000;$_++while$F[0]--;s/(..)(\d+)/-$2-$1/

Wypróbuj online!


PHP , 74 bajty

for($a=AAAA000;$argn--;$a++);echo preg_replace('/(..)(\d+)/','-$2-$1',$a);

Wypróbuj online!

Ponury
źródło
2
+1 dla PHP, wiedziałem, że możemy zwiększać litery w PHP, ale nie wiedziałem, że możemy zwiększać kombinację liter i cyfr. PHP zadziwia mnie każdego dnia! I dzięki nauczyłem się czegoś nowego.
Night2
8

Python 3 , 79 78 77 bajtów

lambda n:f"%c%c-{n%1000:03}-%c%c"%(*(65+n//1000//26**i%26for i in[3,2,1,0]),)

Wypróbuj online!

Jakoś nigdy nie zdałem sobie sprawy, że f"string"skrót formatu istnieje, dopóki nie zobaczyłem odpowiedzi Czarnej Sowy Kai.

Matthew Jensen
źródło
78 bajtów poprzez zastąpienie tupleprzez(*...,)
Czarny Sowa Kai
Użycie f"string"powoduje, że Twoja odpowiedź na Python 3.6+ jest wyjątkowa, tylko dlatego, że jesteś świadomy. Dobra robota!
connectyourcharger
8

Rubin, 61 59 55 bajtów

->n{s='AA-AA000-';eval's.succ!;'*n;s[2]+=s[5,4];s[0,9]}

Również 55 bajtów:

->n{s='AA-AA000-';eval's.succ!;'*n;s[2]+=s.slice!5,4;s}

Wypróbuj online!

To inicjuje licznik AA-AA000-, zwiększa jego nczasy (mnożąc ciąg kodu, który robi to przez n i evaling), a następnie przesuwa ostatnie 4 znaki po 3.

Klamka
źródło
->n{s=('AA-AA000-'..?Z*9).step.take(n)[-1];s[2]+=s.slice!5,4;s}jest dłuższy, ale zastanawiam się, czy można go skrócić.
Eric Duminil
Teoretycznie ->n{s=[*'AA-AA000-'..?Z*9][n];s[2]+=s.slice!5,4;s}powinien działać i ma tylko 50 bajtów długości, ale najpierw generuje każdą możliwą płytkę. : - /
Eric Duminil
1
„s + = s.slice! 3,2” dla 50 bajtów
GB
Powinno to również zadziałać: 45 bajtów
GB
7

PHP , 96 84 79 bajtów

-5 bajtów dzięki świetnym komentarzom Ismael Miguel .

for($s=AAAA;$x++^$argn/1e3;)$s++;printf('%.2s-%03u-'.$s[2].$s[3],$s,$argn%1e3);

Wypróbuj online!

Korzystam z faktu, że możesz zwiększać litery w PHP! Tak AAAA++się stanie AAABi AAAZ++stanie się AABA. Obliczam, ile razy litery muszą być zwiększane przez uzyskanie liczby całkowitej input/1000. Następnie zwiększ cztery razy długość czterech znaków, a pierwsze dwa i dwa ostatnie znaki automatycznie staną się lewą i prawą stroną płytki.

Na przykład dla wprowadzenia 675999liczby przyrostów liter jest (int)(675999 / 1000) = 675, tak AAAAsię stanie AAZZ.

Wreszcie, środkowa liczba jest obliczana przez input%1000i wszystko jest drukowane w określonym formacie za pomocą printf . %.2swypisuje pierwsze dwa znaki ciągu, %03uuzupełnia cyfrę po lewej stronie 3 zerami.

Noc 2
źródło
2
@Elcan Przepraszamy, naprawiono problemy kosztem 12 bajtów. Mam wytłumaczenie, że jestem atakowany przez trzy koty, z powodu mojego bałaganu: P
Night2
1
Zamiast %0.2sciebie możesz pisać %.2s. To oszczędza 1 bajt. (Mała wskazówka: jeśli chcesz wypisać liczbę dziesiętną z określoną liczbą miejsc dziesiętnych, możesz zrobić %.2f(lub jakikolwiek inny modyfikator), jak to działa w ten sam sposób)
Ismael Miguel
1
@ IsmaelMiguel Dzięki, nie wiedziałem, że możemy upuścić 0. Edycja: patrząc na dokumentację, wydaje mi się, że nawet jej nie potrzebowałem: P
Noc2
1
Och, tak, możesz to upuścić. Możesz to zrobić $x++^$argn/1e3zamiast $x++<(0^$argn/1e3)i powinieneś zapisać 4 bajty. Ta pętla aż do ($x++^$argn/1e3) === 0, i to 0przy $xi $argn/1e3są tym samym całkowitą ilość (stosując ^rzuci numery na całkowitą). Możesz tego spróbować na sandbox.onlinephpfunctions.com/code/…
Ismael Miguel
1
@IsmaelMiguel Jeszcze raz dziękuję, bardzo sprytny pomysł.
Uczyniłeś
7

C, 88 86 bajtów

# zdefiniować d (b) a / b / 1000% 26 + 65
f (a) {printf ("% c% c-% 03d-% c% c", d (17576), d (676), a% 1000, d (26), d (1));}

Całkiem proste, wykorzystuje podział i moduł do wyodrębnienia pól, dodaje litery „A” dla liter, aby zamapować je na znaki ASCII i formatowanie printf dla liczb.

Wypróbuj online!

Sir_Lagsalot
źródło
6

Haskell, 85 81 79 77 bajtów

([h++'-':n++'-':t|h<-q"AZ",t<-q"AZ",n<-q"099"]!!)
q g=mapM(\_->[g!!0..g!!1])g

Wypróbuj online!

nimi
źródło
6

05AB1E , 25 22 20 bajtów

Au2ããs₄‰`UèX₄+¦'-.øý

-2 bajty (i zwiększono wydajność, nie generując całej listy) dzięki @Grimy .

Indeksowanie na podstawie 0.

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

Au            # Push the lowercase alphabet, and uppercase it
  2ã          # Create all possible pairs by taking the cartesian product with itself:
              #  ["AA","AB","AC",...,"ZY","ZZ"]
    ã         # Get the cartesian product of this list with itself:
              #  [["AA","AA"],["AA","AB"],...,["ZZ","ZZ"]]
s             # Swap to push the (implicit) input
 ₄‰           # Take the divmod-1000 of it
              #  i.e. 7483045 becomes [7483,45]
    `         # Push these values separated to the stack
     U        # Pop and store the remainder part in variable `X`
      è       # Index the integer part into the list of letter-pairs we created earlier
              #  i.e. 7483 will result in ["AL","BV"]
X             # Push the remainder part from variable `X` again
 ₄+           # Add 1000 to it
   ¦          # And remove the leading 1 (so now the number is padded with leading 0s)
              #  i.e. 45 becomes 1045 and then "045"
    '-.ø     '# Surround this with "-" (i.e. "045" becomes "-045-")
        ý     # Join the two pairs of letters by this
              #  i.e. ["AL","BV"] and "-045-" becomes "AL-045-BV"
              # (after which the top of the stack is output implicitly as result)

Ostatnia część ( s₄‰`UèX₄+¦'-.øý) może być I₄÷èI₄+3.£.ý'-ýalternatywą dla równych bajtów:
Wypróbuj online lub sprawdź wszystkie przypadki testowe .

I₄÷           # Push the input, integer-divided by 1000
   è          # Use it to index into the letter-pairs we created earlier
              #  i.e. 7483045 becomes 7483 and then ["AL","BV"]
I₄+           # Push the input again, and add 1000
   3.£        # Only leave the last three digits
              #  i.e. 7483045 becomes 7484045 and then "045"
            # Intersperse the pair with this
              #  i.e. ["AL","BV"] and "045" becomes ["AL","045","BV"]
        '-ý  '# And join this list by "-"
              #  i.e. ["AL","045","BV"] becomes "AL-045-BV"
              # (after which the top of the stack is output implicitly as result)
Kevin Cruijssen
źródło
1
20 z Au2ããI₄‰`UèX₄+¦'-.øýlub Au2ããI₄÷èI₄+3.£'-.øý.
Grimmy
1
@Grimy Thanks! A teraz jest też znacznie szybszy, nie generując i nie indeksując do pełnej listy. :)
Kevin Cruijssen
6

J , 56 49 46 bajtów

226950 A.'--',7$_3|.4,@u:65 48+/(4 3#26 10)#:]

Wypróbuj online!

-3 bajty dzięki FrownyFrog

Cała sprawa to tylko 7 zagnieżdżonych pociągów - jeśli to nie jest fajne, co to jest?

  ┌─ 226950                                            
  ├─ A.                                                
  │        ┌─ '--'                                     
──┤        ├─ ,                                        
  │        │      ┌─ 7                                 
  └────────┤      ├─ $                                 
           │      │   ┌─ _3                            
           └──────┤   ├─ |.                            
                  │   │    ┌─ 4                        
                  └───┤    │     ┌─ ,                  
                      │    ├─ @ ─┴─ u:                 
                      └────┤                           
                           │     ┌─ 65 48              
                           │     ├─ / ───── +          
                           └─────┤                     
                                 │       ┌─ '4 3#26 10'
                                 └───────┼─ #:         
                                         └─ ]         
Jonasz
źródło
1
Chłodny! Użycie permutacji to dobry sposób na sformatowanie powstałego ciągu.
Galen Iwanow
1
46
FrownyFrog
Dzięki @FrownyFrog!
Jonasz
5

R , 101 bajtów

b=0:3;a=scan()%/%c(10^b,1e3*26^b)%%rep(c(10,26),e=4);intToUtf8(c(a[8:7],-20,a[3:1]-17,-20,a[6:5])+65)

Wypróbuj online!

Wykonuje tylko potrzebne obliczenia arytmetyczne. Zapisałem 5 bajtów, włączając w wektorze abezużyteczną wartość w a[4], pozwalając mi ponownie użyć wektora pomocnika b.

BAB-012-CD26×26×1000=676000nn %/% 676000 %% 26%/%%%

Robin Ryder
źródło
4

Galaretka ,  26  22 bajtów

ØAṗ2,`ØDṗ3¤ṭŒp⁸ị2œ?j”-

Monadyczny link akceptujący liczbę całkowitą (1-indeksowaną), która daje listę znaków ... Szalenie powolne, ponieważ najpierw buduje wszystkie tablice!

Wypróbuj online! (przyzwyczajenie kompletna)
Lub spróbuj zmniejszoną wersję alfabetu (tylko „ABC” na listach).


Dla kodu, który kończy się na czas, oto 32-bajtowy pełny program (indeksowany 0), który zamiast tego tworzy pojedynczą płytkę przy użyciu modułowej arytmetycznej i numerycznej dekompresji bazy:

dȷ+“©L§“£ż’µḢṃØAṙ1¤ḊŒHW€jDḊ€$j”-

Spróbuj tego!

Jonathan Allan
źródło
Wygląda na to, że brakuje mu kresek, więc na razie nie pasuje do zasad wyzwania: P
Elcan
1
Ach, całkowicie je zignorowałem jako swego rodzaju separator! To robi różnicę dla tych metod :(
Jonathan Allan
Przepraszam za to: c Nadal miło widzieć, jak to się robi w Galaretce, nawet bez!
Elcan
Dodano 7 bajtów, aby je dodać, całkiem pewny, że teraz jest krótsza ogólna metoda ...
Jonathan Allan
Ups, dzięki @Grimy - może również golfa o 3, póki tu jestem: p - Jonathan Allan 1 minutę temu
Jonathan Allan
3

Węgiel drzewny , 33 bajty

Nθ¹✂I⁺θφ±³≔⪪⍘⁺X²⁶¦⁵÷θφα²η¹⊟ηM⁹←⊟η

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

Nθ

Wpisz liczbę.

¹

Wydrukuj a -.

✂I⁺θφ±³

Dodaj 1000 do liczby, a następnie rzutuj wynik na ciąg i wydrukuj trzy ostatnie cyfry.

≔⪪⍘⁺X²⁶¦⁵÷θφα²η

Podziel liczbę przez 1000, a następnie dodaj 26⁵, więc konwersja do niestandardowej bazy za pomocą wielkich liter alfabetu daje ciąg o długości 6, który jest następnie dzielony na pary liter.

¹

Wydrukuj a -.

⊟η

Wydrukuj ostatnią parę liter.

M⁹←

Przejdź na początek tablicy rejestracyjnej.

⊟η

Wydrukuj pozostałe żądane litery.

Neil
źródło
3

Perl 6 , 42 bajtów

{S/(..)(\d+)/-$1-$0/}o{('AAAA000'..*)[$_]}

Wypróbuj online!

Rozwiązanie Port of Grimy's Perl 5. Wolny dla dużych wartości wejściowych.

nwellnhof
źródło
3

Excel, 183 167 155 147 bajtów

-16 bajtów dzięki @Neil. (6 przy użyciu E3)

-12 bajtów dzięki @Keeta. ( TRUNCzamiast QUOTIENT)

-8 bajtów dzięki @Jonathan Larouche ( INTzamiast TRUNC)

=CHAR(65+INT(A1/17576E3))&CHAR(65+MOD(INT(A1/676E3),26))&"-"&TEXT(MOD(A1,1E3),"000")&"-"&CHAR(65+MOD(INT(A1/26E3),26))&CHAR(65+MOD(INT(A1/1E3),26))

Łączy 5 części:

CHAR(65+INT(A1/17576E3))
CHAR(65+MOD(INT(A1/676E3),26))
TEXT(MOD(A1,1E3),"000")
CHAR(65+MOD(INT(A1/26E3),26))
CHAR(65+MOD(INT(A1/1E3),26))
Wernisch
źródło
Nie MOD(QUOTIENT(A1,1E3),26)działa? Ponadto, dlaczego 1E3dla 1000ale nie 26E3etc?
Neil
Zaoszczędź jeszcze, usuwając całkowicie TRUNC i przenosząc podział do wewnątrz MOD. = ZNAK (65 + A1 / 17576E3) i ZNAK (65 + MOD (A1 / 676E3,26)) i „-” i TEKST (MOD (A1,1E3), „000”) oraz „-” i ZNAK (65 + MOD (A1 / 26E3,26)) i CHAR (65 + MOD (A1 / 1E3,26)) zmniejszając go do 127 bajtów.
Keeta
Miałem na myśli usunięcie QUOTIENT. Początkowo sugerowałem zmianę ilorazu na obcięcie za pomocą / zamiast przecinka.
Keeta
@ Keeta, Twoje 127-bajtowe rozwiązanie zawiedzie w przypadku niektórych wartości: np. 456 975 996->[Z-996-ZZ
Wernisch
@Keeta, Wydaje się, że CHAR(65+)po cichu obcina miejsca po przecinku do %.9999997614649. Większy niż to jest zaokrąglany w górę. Porównaj CHAR(65+24.9999997614649)i CHAR(65+24.999999761465).
Wernisch
2

Czysty , 107 bajtów

import StdEnv
A=['A'..'Z']
N=['0'..'9']
$n=[[a,b,'-',x,y,z,'-',c,d]\\a<-A,b<-A,c<-A,d<-A,x<-N,y<-N,z<-N]!!n

Wypróbuj online!

Definiuje $ :: Int -> [Char]podanie n-tej zerowej tablicy rejestracyjnej.

Obrzydliwe
źródło
2

Japt , 21 bajtów

Nieprzyzwoicie wolny! Poważnie, nawet nie próbuj go uruchamiać!

Porada dla Kevina, za uświadomienie mi, gdzie się mylę, walcząc o to, aby wczoraj wieczorem zadziałało.

;gBï ï ïq#d0o ùT3 û-5

Spróbuj - ogranicza zakres liczb do 000-005.

;gBï ï ïq#d0o ùT3 û-5     :Implicit input of integer
 g                        :Index into
; B                       :  Uppercase alphabet
   ï                      :  Cartesian product with itself
     ï                    :  Cartesian product of the result with itself
       ï                  :  Cartesian product of that with
         #d0              :    1000
            o             :    Range [0,1000)
              ùT3         :    Left pad each with 0 to length 3
                  û-5     :    Centre pad each with "-" to length 5
        q                 :  Join the first element (the 2 pairs of letters) with the second (the padded digit string) 
Kudłaty
źródło
2

Dalej (gforth) , 94 bajty

: x /mod 65 + emit ; : f dup 1000 / 17576 x 676 x ." -"swap 0 <# # # # #> type ." -"26 x 1 x ;

Wypróbuj online!

0-indeksowane. Dane wejściowe są pobierane z góry stosu

Wyjaśnienie kodu

\ extract out some common logic
: x             \ start a new word definition
  /mod          \ divide first argument by second and get both quotient and remainder
  65 +          \ add 65 (ascii A) to quotient
  emit          \ output
;               \ end word definition

: f             \ start a new word definition
  dup 100 /     \ duplicate input and divide by 1000
  17576 x       \ divide by 26^3 and output ascii char
  676 x         \ divide by 26^2 and output ascii char
  ." -"         \ output "-"
  swap 0        \ grab original number and convert to double-cell number
  <# # # # #>   \ convert last 3 chars of number to a string
  type ." -"    \ output string followed by "-"
  26 x          \ divide result of last mod by 26 and output ascii char
  1 x           \ output ascii char for remaining amount
;               \ end word definition
reffu
źródło
2

q , 78 bajtów

{sv["-","0"^-4$($:[x mod 1000]),"-"]2 2#(|).Q.A mod[x div 1000*26 xexp(!)4]26}

                                                    x div 1000*26 xexp(!)4     / input (floor) divided by 1000*26 ^ 0 1 2 3
                                                mod[                      ]26  / mod 26
                                           .Q.a                                / alphabet uppercase, indexed into by preceeding lines, for x=1000, we'd get "BAAA"
                                    2 2#(|)                                    / reverse and cut into 2x2 matrix ("AA";"AB")
               ($:[x mod 1000]),"-"                                            / string cast x mod 1000 and append "-"
            -4$                                                                / left pad to length 4, "  0-"
    "-","0"^                                                                   / fill nulls (" ") with "0" and prepend "-"
 sv[              x                ]y                                          / join elems of y by x
bazgranina
źródło
2

T-SQL, 135 bajtów

select concat(CHAR(65+(@i/17576000)),CHAR(65+(@i/676000)%26),'-',right(1e3+@i%1000,3),'-',CHAR(65+(@i/26000)%26),CHAR(65+(@i/1000)%26))
Jonathan Larouche
źródło
1

Python 2 , 88 bajtów

lambda n:g(n/676000)+'-%03d-'%(n%1000)+g(n/1000)
g=lambda n:chr(65+n/26%26)+chr(65+n%26)

Wypróbuj online!

Chas Brown
źródło
Zapis przez pomyłkę pod moją odpowiedzią można również zastosować do Pythona 2
Black Owl Kai
1

Czerwony , 130 127 bajtów

func[n][g: func[a b c][t: copy""loop a[insert t b +(n % c)n: n / c]t]a: g 3 #"0"10
s: g 4 #"A"26 rejoin[s/1 s/2"-"a"-"s/3 s/4]]

Wypróbuj online!

Galen Iwanow
źródło
1

Python 3 , 89 bajtów

lambda n:h(n//676)+f"-{n%1000:03}-"+h(n)
h=lambda x:'%c%c'%(x//26000%26+65,x//1000%26+65)

Wypróbuj online!

-1 bajt dzięki mypetlion

Czarna sowa Kai
źródło
1
Zmień, chr(x//26000%26+65)+chr(x//1000%26+65)aby '%c%c'%(x//26000%26+65,x//1000%26+65)zapisać 1 bajt.
mypetlion
1

MATLAB , 113 bajtów

c=@(x,p)char(mod(idivide(x,1000*26^p),26)+65);
s=@(n)[c(n,3),c(n,2),num2str(mod(n,1000),'-%03d-'),c(n,1),c(n,0)]

Objaśnienia:

Pierwszy wiersz definiuje funkcję, która wygeneruje char (od Ado Z), funkcję 2 wejść. Numer indeksu xdo przeliczenia na numer rejestracyjny oraz liczba całkowita, pktóra będzie używana jako wykładnik liczby 26 (tj 26^p.). To drugie wejście umożliwia dostosowanie obliczeń dla pierwszej cyfry alfanumerycznej ( p=3) do ostatniej ( p=0).

Na przykład dla drugiej cyfry, cyklicznie co 1000 * 26 * 26 iteracji, operacja: mod(idivide(x,1000*26^2),26)zwraca indeks od 0 do 25, który jest następnie konwertowany na ASCII charprzez dodanie 65 (ponieważ indeks jest 0oparty)

Drugi wiersz po prostu łączy znaki. Każdy znak alfanumeryczny jest obliczany za pomocą funkcji c(x,p), znak numeryczny jest po prostu obliczany za pomocą modulooperacji i konwertowany na ciąg znaków.

Każdy element ciągu składającego się na numer rejestracyjny jest następujący:

digit #     |    how often is it cycled             |  code
----------------------------------------------------------------
digit 1     | cycle every 1000*26*26*26=1000*26^3   | c(n,3) 
digit 2     | cycle every 1000*26*26   =1000*26^2   | c(n,2) 
digit 3,4,5 | cycle every iteration                 | num2str(mod(n,1000),'-%03d-')
digit 6     | cycle every 1000*26      =1000*26^1   | c(n,1) 
digit 7     | cycle every 1000         =1000*26^0   | c(n,0) 

Ponieważ nie mogę pozwolić ci wypróbować MATLAB online ( edytuj: faktycznie możesz wypróbować go online ), dam użytkownikom MATLAB możliwość weryfikacji przypadków testowych:

% chose some test cases
n = uint32([0;1;999;1000;675999;676000;456975999]) ;

% work out their plate numbers
plates = s(n) ;

% display results
fprintf('\n%10s | Plate # \n','Index')
for k=1:numel(n)
    fprintf('%10d : %s\n',n(k),plates(k,:))
end

wyjścia:

     Index | Plate # 
         0 : AA-000-AA
         1 : AA-001-AA
       999 : AA-999-AA
      1000 : AA-000-AB
    675999 : AA-999-ZZ
    676000 : AB-000-AA
 456975999 : ZZ-999-ZZ

Wariant: Należy pamiętać, że możliwa jest opcja zamiany cyfr na znaki sprintflub fprintfzadbania o nie. Pozwala to uprościć funkcję c, ale ogólnie daje kilka dodatkowych bajtów w tej implementacji (119 bajtów):

c=@(x,p)mod(idivide(x,1000*26^p),26)+65 ;
s=@(n)sprintf('%c%c-%03d-%c%c\n',[c(n,3),c(n,2),mod(n,1000),c(n,1),c(n,0)]')
Hoki
źródło
1

C (gcc) , 136 106 105 bajtów

#define P(i)s[i]=65+x%26;x/=26;
z;s[]=L"  -%03d-  ";f(x){z=x%1000;x/=1e3;P(9)P(8)P(1)P(0)wprintf(s,z);}

Wypróbuj online!

-7 bajtów z celingcat jest rozwiązanie , za pomocą dodatkowych -23 inspirowany przez to

-1 bajt z ceilingcat za rozwiązanie zmieniając char[]Do wchar_t[]niejawnie rzutować naint[]

Wykorzystuje indeksowanie 0.

Wyjaśnienie / Niegolfowany:

int s[] = L"  -%03d-  "; // Pre-made wide-string with dashes and ending null byte
                         // and wprintf directive for digits
int z;                   // Temporary variable to store the digit part
void f(int x) {
    z = x % 1000;        // The digits represent x % 1000
    x /= 1000;           
    s[9] = 'A' + x % 26; // Place least significant letter
    x /= 26;             // Divide off least significant letter
    s[8] = 'A' + x % 26; // Place second letter
    x /= 26;             // Divide off second letter
    s[1] = 'A' + x % 26; // Place third letter
    x /= 26;             // Divide off third letter
    s[0] = 'A' + x;      // Place fourth letter (Don't need to % 26 because x < 26 now)
    wprintf(s, z); // Print finished string (with x%1000 replacing %03d)
}
pizzapanty184
źródło
@ceilingcat Thanks! Korzystając z tego pomysłu, usunąłem parametry ai bz makra i
zapisałem
0

Python 3 , 161 bajtów

i,t,u,v,a,c,f=int(input()),1000,676,26,ord('A'),chr,lambda x:c(a+x//v)+c(a+x%v)
m,n=i%t,i//t
e,o=n%u,n//u
print('-'.join([f(o),(3-len(str(m)))*'0'+str(m),f(e)]))

Wypróbuj online!

Koishore Roy
źródło