Sandkasten

Französische Kennzeichen

Französische Kennzeichen werden nach einem bestimmten Muster aus Zahlen und Buchstaben in aufeinanderfolgender Reihenfolge angezeigt:AB-012-CD

Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die für eine bestimmte Nummer das entsprechende französische Kennzeichen ausgibt . Ihr Programm sollte keine Sonderfälle behandeln, wie auf der verlinkten Seite angegeben. Es sollte in der Lage sein, alle 26*26*1000*26*26 => 456 976 000möglichen Kennzeichen zu generieren , oder soweit Ihre Sprache dies unterstützt.

Das Nummerierungssystem sieht wie folgt aus:

• AA-000-AA bis AA-999-AA (Zahlen entwickeln sich zuerst);
• AA-000-AB bis AA-999-AZ (dann der letzte Buchstabe rechts);
• AA-000-BA bis AA-999-ZZ (dann der erste Buchstabe rechts);
• AB-000-AA bis AZ-999-ZZ (dann der letzte Buchstabe links);
• BA-000-AA bis ZZ-999-ZZ (dann der erste Buchstabe links).

Eingang

• Der Index der Kennzeichen als Ganzzahl

Ausgabe

• Das entsprechende französische Kennzeichen

Zusätzliche Information

• Buchstaben müssen in Großbuchstaben geschrieben werden
• Sie können sowohl eine 0-basierte als auch eine 1-basierte Indexierung verwenden, um die Platten zu generieren (dh AA-000-AA kann der Indexierung entsprechen 0oder 1vorausgesetzt, alle anderen Testfälle verwenden dieselbe Indexierung.

Das ist Code-Golf , kürzeste Antwort in jeder Sprache gewinnt!

Testfälle (0-basierte Indizierung)

          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 (keine externen Utensilien), 64

• 2 Bytes dank @NahuelFouilleul gespart

x={A..Z}
eval f=($x$x-%03d-$x$x)
printf ${f[$1/1000]} $[$1%1000]

Probieren Sie es online! - Es dauert ungefähr 10 Sekunden, um die 7 Testfälle zu durchlaufen.

• Zeile 1 ist eine einfache Zuordnung eines Strings zu einer Variablen
• Zeile 2 ist eine geschweifte Klammer, um ein Array von Zeichenfolgen im printf-Format zu erstellen, eine für alle 456.976 möglichen Buchstabenkombinationen, wobei die Ziffern noch nicht angegeben sind. Das evalist erforderlich, um sicherzustellen, dass die variable Expansion (von x) vor der Klammerexpansion erfolgt.
• Zeile 3 indiziert das Array, um die entsprechende Formatzeichenfolge abzurufen, und verwendet den Ziffernteil als Parameter.

Perl 5 (-ap), 47 Bytes

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

Probieren Sie es online!

PHP , 74 Bytes

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

Probieren Sie es online!

Python 3 , 79 78 77 Bytes

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

Probieren Sie es online!

Ich habe irgendwie nie bemerkt, dass die f"string"Formatverknüpfung existiert, bis ich die Antwort von Black Owl Kai gesehen habe.

Ruby, 61 59 55 Bytes

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

Auch 55 Bytes:

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

Probieren Sie es online!

Dies initialisiert einen Zähler auf AA-AA000-, erhöht ihn n(durch Multiplizieren einer Zeichenfolge des Codes, der dies tut, mit n und evaling) und verschiebt dann die letzten 4 Zeichen nach dem 3. Zeichen.

PHP , 96 84 79 Bytes

-5 Byte dank Ismael Miguels großartigen Kommentaren.

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

Probieren Sie es online!

Ich nutze die Tatsache, dass Sie Buchstaben in PHP erhöhen können! So AAAA++würde es werden AAABund AAAZ++würde es werden AABA. Ich berechne, wie oft die Buchstaben erhöht werden müssen, indem ein ganzzahliger Teil von erhalten wird input/1000. Erhöhen Sie dann die Länge der vier Zeichen um das Vielfache, und die ersten beiden und letzten beiden Zeichen werden automatisch zur linken und rechten Seite der Platte.

Zum Beispiel für die Eingabe der 675999Anzahl der Buchstabeninkremente ist (int)(675999 / 1000) = 675, so AAAAwird es werden AAZZ.

Schließlich wird die mittlere Zahl von berechnet input%1000und alles mit Hilfe von printf im angegebenen Format gedruckt . %.2sdruckt die ersten beiden Zeichen der Zeichenkette und %03ufüllt die Zahl links mit 3 Nullen auf.

C, 88 86 Bytes

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

Ganz einfach, es werden Division und Modul zum Extrahieren der Felder verwendet, 'A' für die Buchstaben hinzugefügt, um sie ASCII-Zeichen zuzuordnen, und printf-Formatierungen für die Zahlen.

Probieren Sie es online!

Haskell, 85 81 79 77 Bytes

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

Probieren Sie es online!

05AB1E , 25 22 20 Bytes

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

-2 Bytes (und erhöhte die Leistung, indem nicht die gesamte Liste generiert wurde) dank @Grimy .

0-basierte Indizierung.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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)

Der letzte Teil ( s₄‰`UèX₄+¦'-.øý) könnte I₄÷èI₄+3.£.ý'-ýeine Alternative mit gleichen Bytes sein:
Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

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 Bytes

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

Probieren Sie es online!

-3 Bytes dank FrownyFrog

Das Ganze sind nur 7 verschachtelte Züge - wenn das keinen Spaß macht, was ist das dann?

  ┌─ 226950                                            
  ├─ A.                                                
  │        ┌─ '--'                                     
──┤        ├─ ,                                        
  │        │      ┌─ 7                                 
  └────────┤      ├─ $                                 
           │      │   ┌─ _3                            
           └──────┤   ├─ |.                            
                  │   │    ┌─ 4                        
                  └───┤    │     ┌─ ,                  
                      │    ├─ @ ─┴─ u:                 
                      └────┤                           
                           │     ┌─ 65 48              
                           │     ├─ / ───── +          
                           └─────┤                     
                                 │       ┌─ '4 3#26 10'
                                 └───────┼─ #:         
                                         └─ ]         

JavaScript (Node.js) , 82 Byte

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

Probieren Sie es online!

Ruby , 51 Bytes

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

Probieren Sie es online!

R 101 Bytes

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)

Probieren Sie es online!

Führt nur die erforderlichen arithmetischen Berechnungen durch. Ich habe 5 Bytes gespart , indem ich aeinen nutzlosen Wert bei in den Vektor aufgenommen habe a[4], damit ich den Hilfsvektor wieder verwenden kann b.

BAB-012-CD$26\times26\times1000=676\,000$nn %/% 676000 %% 26%/%%%

Jelly ,  26  22 Bytes

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

Ein monadischer Link, der eine ganze Zahl (1-indiziert) akzeptiert, die eine Liste von Zeichen liefert ... Verrückt langsam, da alle Platten zuerst erstellt werden!

Probieren Sie es online! (wird nicht vervollständigt)
Oder versuchen Sie es mit einer reduzierten Alphabet-Version (nur "ABC" für die Buchstaben).

Für Code, der zeitnah fertiggestellt wird, gibt es hier ein 32-Byte-Vollprogramm (0-indexiert), das die einzelne Platte stattdessen mit modularer arithmetischer und numerischer Basisdekomprimierung erstellt:

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

Probier diese!

APL + WIN, 61 Bytes

Fordert zur Eingabe einer Ganzzahl auf:

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

Probieren Sie es online! Mit freundlicher Genehmigung von Dyalog Classic

Holzkohle , 33 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Ｎθ

Geben Sie die Nummer ein.

¹

Drucken Sie a -.

✂Ｉ⁺θφ±³

Addieren Sie 1000 zu der Zahl, setzen Sie das Ergebnis in eine Zeichenfolge um und drucken Sie die letzten drei Ziffern.

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

Teilen Sie die Zahl durch 1000 und addieren Sie dann 26⁵, sodass bei der Konvertierung in eine benutzerdefinierte Basis mit dem Großbuchstaben eine Zeichenfolge mit der Länge 6 entsteht, die dann in Buchstabenpaare aufgeteilt wird.

¹

Drucken Sie a -.

⊟η

Drucken Sie das letzte Buchstabenpaar.

Ｍ⁹←

Gehen Sie an den Anfang des Nummernschilds.

⊟η

Drucken Sie den Rest der gewünschten Buchstaben.

Perl 6 , 42 Bytes

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

Probieren Sie es online!

Port of Grimy's Perl 5-Lösung. Langsam für große Eingabewerte.

Excel, 183 167 155 147 Bytes

-16 Bytes dank @Neil. (6 unter Verwendung von E3)

-12 Bytes dank @Keeta. ( TRUNCstatt QUOTIENT)

-8 Bytes dank @Jonathan Larouche ( INTanstelle von 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))

Verkettet 5 Teile:

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

Sauber , 107 Bytes

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

Probieren Sie es online!

Definiert die $ :: Int -> [Char]Angabe des n-ten Kennzeichens mit Index Null.

Japt , 21 Bytes

Obszön langsam! Im Ernst, versuchen Sie nicht einmal, es auszuführen!

Ein Tipp an Kevin , der mir klar gemacht hat, wo ich falsch gelegen habe, als ich gestern Abend darum gekämpft habe, dass das funktioniert.

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

Probieren Sie es aus - begrenzt den Nummernkreis auf 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) 

Viertens (gviertens) , 94 Bytes

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

Probieren Sie es online!

0-indiziert. Die Eingabe erfolgt von der Stapelspitze

Code Erklärung

\ 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

T-SQL, 135 Byte

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 Bytes

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

Probieren Sie es online!

Rot , 130 127 Bytes

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

Probieren Sie es online!

Python 3 , 89 Bytes

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

Probieren Sie es online!

-1 Byte dank mypetlion

MATLAB , 113 Bytes

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

Erklärungen:

Die erste Zeile definiert eine Funktion, die aus 2 Eingängen ein Zeichen (von Abis Z) erzeugt. Die xzu konvertierende Indexnummer und eine Ganzzahl p, die als Exponent für 26 (dh 26^p) verwendet wird. Mit dieser zweiten Eingabe können die Berechnungen für die erste alphanumerische Kennziffer ( p=3) bis zur letzten Ziffer ( ) angepasst werden p=0.

Beispiel: Für die zweite Ziffer, die alle 1000 * 26 * 26 Iterationen durchlaufen wird, wird die folgende Operation ausgeführt: Es wird mod(idivide(x,1000*26^2),26)ein Index zwischen 0 und 25 zurückgegeben, der dann in ein ASCII-Format konvertiert wirdchar durch Hinzufügen von 65 Format (da der Index 0basiert).

Die zweite Zeile verkettet die Zeichen einfach miteinander. Jedes alphanumerische Zeichen wird mit der Funktion c(x,p)berechnet, das numerische Zeichen wird einfach mit a berechnetmodulo Operation und in eine Zeichenfolge umgewandelt.

Jede Komponente der Zeichenfolge, aus der die Kennzeichen bestehen, lautet wie folgt:

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) 

Da ich es nicht zulassen kann, dass Sie MATLAB online testen ( Bearbeiten: Sie können es tatsächlich online testen), werde ich den MATLAB-Benutzern die Möglichkeit geben, die Testfälle zu überprüfen:

% 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

Ausgänge:

     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

Variante: Beachten Sie, dass die Option lassen sprintfoder fprintfvon der Anzahl an Zeichenkonvertierung kümmern uns möglich ist . cDies ermöglicht eine Vereinfachung der Funktion , führt jedoch insgesamt zu ein paar weiteren Bytes in dieser Implementierung (119 Bytes):

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

q 78 Bytes

{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

C (GCC) , 136 106 105 Bytes

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

Probieren Sie es online!

-7 Bytes von celingcat ‚s Lösung , weitere -23 inspiriert

-1 Byte von der Lösung von ceilingcat durch Ändern der char[]in wchar_t[]implizit umgewandeltint[]

Verwendet eine 0-basierte Indizierung.

Erklärung / Ungolfed:

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 Bytes

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

Probieren Sie es online!

Kotlin , 93 Bytes

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

Probieren Sie es online!

Python 3 , 161 Bytes

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

Probieren Sie es online!