Französische Kennzeichen

41

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
Elcan
quelle
2
Hier sind einige weitere Anforderungen, direkt von Wikipedia, wenn Sie eine härtere Variation erstellen möchten: "Diese Zahl schließt drei Buchstaben aus, die nicht verwendet werden: I, O und U, da sie mit 1, 0 bzw. V verwechselt werden können. Es schließt auch die SS-Kombination aus, da sie an die Nazi-Organisation und den Zweiten Weltkrieg in der ersten Buchstabengruppe erinnert, da sie auf ein vorübergehendes Kennzeichen hinweist. "
Eric Duminil
4
@EricDuminil Ich habe es absichtlich ausgeschlossen, weil es der Herausforderung gerade unmögliche Einschränkungen hinzugefügt hat. Aber es ist wahr, es könnte interessant sein, aber selbst mit "Bonuspunkten" bezweifle ich, dass es sich lohnen würde, diese Regeln umzusetzen
Elcan,

Antworten:

17

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.
Digitales Trauma
quelle
1
-2Bytes
Nahuel Fouilleul
13

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!

Grimmig
quelle
2
+1 für PHP, ich wusste, dass wir Buchstaben in PHP erhöhen können, aber ich wusste nicht, dass wir eine Kombination aus Buchstaben und Ziffern erhöhen können. PHP überrascht mich jeden Tag! Und danke habe ich was neues gelernt.
Nacht,
8

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.

Matthew Jensen
quelle
78 Bytes durch Ersetzen tupledurch(*...,)
Black Owl Kai
Durch f"string"die Verwendung von wird Ihre Antwort exklusiv für Python 3.6+, nur damit Sie sich dessen bewusst sind. Gute Arbeit!
connectyourcharger
8

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.

Türknauf
quelle
->n{s=('AA-AA000-'..?Z*9).step.take(n)[-1];s[2]+=s.slice!5,4;s}ist länger, aber ich frage mich, ob es möglich ist, es zu verkürzen.
Eric Duminil
Theoretisch ->n{s=[*'AA-AA000-'..?Z*9][n];s[2]+=s.slice!5,4;s}sollte es funktionieren und ist nur 50 Bytes lang, aber es generiert zuerst jede mögliche Platte. : - /
Eric Duminil
1
"s + = s.slice! 3,2" für 50 Bytes
GB
Dann sollte das auch funktionieren: 45 Bytes
GB
7

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.

Night2
quelle
2
@Elcan Sorry, das Problem wurde mit 12 Bytes behoben. Ich habe eine Entschuldigung von drei Katzen angegriffen zu sein, für meine vermasselt: P
Night2
1
Anstelle von %0.2sdir kannst du schreiben %.2s. Das erspart Ihnen 1 Byte. (Ein kleiner Tipp: Wenn Sie eine Dezimalzahl mit einer bestimmten Anzahl von Dezimalstellen ausgeben möchten, können Sie %.2f(oder einen anderen Modifikator) so vorgehen, wie es auch funktioniert.)
Ismael Miguel
1
@IsmaelMiguel Danke, ich wusste nicht, dass wir das fallen lassen können 0. Edit: In den Dokumentationen scheint es, als hätte ich es überhaupt nicht
gebraucht
1
Oh ja, die kannst du fallen lassen. Sie können $x++^$argn/1e3stattdessen auch $x++<(0^$argn/1e3)4 Bytes einsparen. Dies wird wiederholt, bis ($x++^$argn/1e3) === 0und es ist, 0wenn $xund $argn/1e3dieselbe ganze Zahl sind (mit ^wird die Zahl in eine ganze Zahl umgewandelt). Sie können dies auf sandbox.onlinephpfunctions.com/code/…
Ismael Miguel
1
@IsmaelMiguel Nochmals vielen Dank, sehr clevere Idee. Sie haben diese Antwort kürzer als JS 1 gemacht und das ist ein Erfolg: P
Night2
7

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!

Sir_Lagsalot
quelle
6

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)
Kevin Cruijssen
quelle
1
20 mit Au2ããI₄‰`UèX₄+¦'-.øýoder Au2ããI₄÷èI₄+3.£'-.øý.
Grimmy
1
@ Grimy Danke! Und jetzt geht es auch viel schneller, wenn nicht die gesamte Liste generiert und indiziert wird. :)
Kevin Cruijssen
6

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'
                                 └───────┼─ #:         
                                         └─ ]         
Jona
quelle
1
Cool! Die Verwendung der Permutation ist eine gute Möglichkeit, die resultierende Zeichenfolge zu formatieren.
Galen Ivanov
1
46
FrownyFrog
Vielen Dank @FrownyFrog!
Jonah,
5

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-CD26×26×1000=676000nn %/% 676000 %% 26%/%%%

Robin Ryder
quelle
4

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!

Jonathan Allan
quelle
Vermisst die Striche, wie es scheint, und entspricht
vorerst
1
Ah, ich habe sie als eine Art Trennzeichen völlig ignoriert! Macht einen großen Unterschied für diese Methoden: (
Jonathan Allan
Tut mir leid, dass: c Es ist immer noch schön zu sehen, dass es in Jelly gemacht wurde, auch ohne!
Elcan,
7 Byes hinzugefügt, um sie hinzuzufügen, ziemlich sicher, dass es jetzt eine kürzere Gesamtmethode gibt ...
Jonathan Allan
Ups, danke @Grimy - kann genauso gut um 3 Golf spielen, während ich hier bin: p - Jonathan Allan vor 1 Minute
Jonathan Allan
3

Holzkohle , 33 Bytes

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

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

Nθ

Geben Sie die Nummer ein.

¹

Drucken Sie a -.

✂I⁺θφ±³

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

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

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.

M⁹←

Gehen Sie an den Anfang des Nummernschilds.

⊟η

Drucken Sie den Rest der gewünschten Buchstaben.

Neil
quelle
3

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.

nwellnhof
quelle
3

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))
Wernisch
quelle
Geht MOD(QUOTIENT(A1,1E3),26)nicht Auch warum 1E3für 1000aber nicht 26E3etc?
Neil,
Sparen Sie noch mehr, indem Sie TRUNC vollständig entfernen und die Unterteilung in den MOD verschieben. = CHAR (65 + A1 / 17576E3) & CHAR (65 + MOD (A1 / 676E3,26)) & "-" & TEXT (MOD (A1,1E3), "000") & "-" & CHAR (65 + MOD (A1 / 26E3,26)) & CHAR (65 + MOD (A1 / 1E3,26)) bringt es auf 127 Bytes herunter.
Keeta
Ich wollte QUOTIENT entfernen. Ursprünglich habe ich vorgeschlagen, den Quotienten durch ein / anstelle eines Kommas abzuschneiden.
Keeta
@Keeta, Ihre 127-Byte-Lösung schlägt für einige Werte fehl: zB 456 975 996->[Z-996-ZZ
Wernisch
@ Keeta, Scheint, als würde CHAR(65+)stumm Dezimalstellen bis zu abgeschnitten %.9999997614649. Größer als das wird aufgerundet. Vergleichen CHAR(65+24.9999997614649)und CHAR(65+24.999999761465).
Wernisch
2

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.

Οurous
quelle
2

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) 
Zottelig
quelle
2

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
reffu
quelle
2

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))
Jonathan Larouche
quelle
1

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!

Chas Brown
quelle
Das Speichern durch mypetition unter meiner Antwort kann auch für Python 2 angewendet werden
Black Owl Kai
1

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!

Galen Ivanov
quelle
1

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

Schwarze Eule Kai
quelle
1
Wechseln Sie chr(x//26000%26+65)+chr(x//1000%26+65)zu '%c%c'%(x//26000%26+65,x//1000%26+65), um 1 Byte zu speichern.
Mypetlion
1

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)]')
Hoki
quelle
1

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
kritzeln
quelle
1

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)
}
Pizzapants184
quelle
@ceilingcat Danke! Mit dieser Idee entfernte ich die aund b-Parameter aus dem Makro und erreichte 106 Bytes
pizzapants184
0

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!

Koishore Roy
quelle