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

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.

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!

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.

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.

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.

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!

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!

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)

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'
                                 └───────┼─ #:         
                                         └─ ]         

JavaScript (Node.js) , 82 bajty

n=>'32-654-10'.replace(/\d/g,x=>Buffer([x&4?n/10**(x-4)%10+48:n/1e3/26**x%26+65]))

Wypróbuj online!

Rubinowy , 51 bajtów

->n{[*?A*4..?Z*4][n/1e3][/../]+"-%03d-"%(n%1e3)+$'}

Wypróbuj online!

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-CD$26\times26\times1000=676\,000$nn %/% 676000 %% 26%/%%%

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!

APL + WIN, 61 bajtów

Monity o liczbę całkowitą:

m←⎕av[4↑66+n←((4⍴26),1E3)⊤⎕]⋄(2↑m),'-',(¯3↑'00',⍕4↓n),'-',2↓m

Wypróbuj online! Dzięki uprzejmości Dyalog Classic

Węgiel drzewny , 33 bajty

Ｎθ¹✂Ｉ⁺θφ±³≔⪪⍘⁺Ｘ²⁶¦⁵÷θφα²η¹⊟ηＭ⁹←⊟η

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

Ｎθ

Wpisz liczbę.

¹

Wydrukuj a -.

✂Ｉ⁺θφ±³

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

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

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.

Ｍ⁹←

Przejdź na początek tablicy rejestracyjnej.

⊟η

Wydrukuj pozostałe żądane litery.

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.

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

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.

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) 

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

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

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

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!

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!

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

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

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

Julia 1.0 , 86 bajtów

i->(join('A'.+digits(i÷1000,base=26,pad=4))string(i%1000,pad=3)*'-')[[4;3;8;5:8;2;1]]

Wypróbuj online!

Kotlin , 93 bajty

{i:Int->val c={v:Int->'A'+i/v/1000%26}
""+c(17576)+c(676)+"-%03d-".format(i%1000)+c(26)+c(1)}

Wypróbuj online!

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!