Plaques d'immatriculation françaises

42

bac à sable

Plaques d'immatriculation françaises

Les plaques d'immatriculation françaises sont classées dans un ordre séquentiel, suivant un modèle spécifique de chiffres et de lettres:AB-012-CD

Défi

Ecrivez un programme ou une fonction qui, pour un numéro donné, affiche le numéro de la plaque d'immatriculation française correspondante . Votre programme ne doit pas gérer les cas particuliers spécifiés dans la page liée. Il devrait être capable de générer toutes 26*26*1000*26*26 => 456 976 000les plaques possibles, ou aussi loin que votre langue le permet.

Le système de numérotation va comme suit:

  • AA-000-AA à AA-999-AA (les nombres évoluent en premier);
  • AA-000-AB à AA-999-AZ (puis la dernière lettre à droite);
  • AA-000-BA à AA-999-ZZ (puis la première lettre à droite);
  • AB-000-AA à AZ-999-ZZ (puis la dernière lettre à gauche);
  • BA-000-AA à ZZ-999-ZZ (puis la première lettre à gauche).

Contribution

  • L'indice du numéro de plaque sous forme d'entier

Sortie

  • Le numéro de la plaque d'immatriculation française correspondante

Information additionnelle

  • Les lettres doivent être majuscules
  • Vous pouvez utiliser les indexes 0 et 1 pour générer les plaques (ce qui signifie que AA-000-AA peut correspondre à 0ou 1en supposant que tous les autres cas de test utilisent la même indexation.

C'est le code-golf , la réponse la plus courte dans toutes les langues gagne!

Cas de test (indexation basée sur 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
la source
2
Voici quelques autres exigences, directement depuis Wikipedia, si vous souhaitez créer une variante plus dure: "Ce chiffre exclut trois lettres qui ne sont pas utilisées: I, O et U, car elles peuvent être confondues avec 1, 0 et V, respectivement. Elle exclut également la combinaison SS car elle rappelle l'organisation nazie et WW dans le premier groupe de lettres, car elle indique une plaque temporaire. "
Eric Duminil
4
@EricDuminil Je l'ai délibérément exclu parce qu'il ajoutait simplement des contraintes insignifiantes au défi. Mais c’est vrai que cela pourrait être intéressant, mais même avec des «points bonus», je doute que l’application de ces règles vaille la peine d’être mise en œuvre
Elcan

Réponses:

17

Pure Bash (sans utils externes), 64

  • 2 octets économisés grâce à @NahuelFouilleul
x={A..Z}
eval f=($x$x-%03d-$x$x)
printf ${f[$1/1000]} $[$1%1000]

Essayez-le en ligne! - Il faut environ 10 secondes pour parcourir les 7 cas de test.

  • La ligne 1 est une simple affectation d'une chaîne à une variable
  • La ligne 2 est une extension pour créer un tableau de chaînes au format printf, une pour toutes les 456 976 combinaisons de lettres possibles, avec les chiffres non encore spécifiés. Le evalest nécessaire pour assurer la dilatation variable (de x) avant l’extension de l’attelle.
  • La ligne 3 indexe le tableau pour obtenir la chaîne de format appropriée et prend la partie chiffres en tant que paramètre.
Trauma numérique
la source
1
-2bytes
Nahuel Fouilleul le
13

Perl 5 (-ap), 47 octets

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

Essayez-le en ligne!


PHP , 74 octets

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

Essayez-le en ligne!

Grimmy
la source
2
+1 pour PHP, je savais que nous pouvions incrémenter des lettres en PHP, mais je ne savais pas que nous pouvions incrémenter une combinaison de lettres et de chiffres. PHP m'épate tous les jours! Et merci j'ai appris quelque chose de nouveau.
Night2 le
8

Python 3 , 79 78 77 octets

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

Essayez-le en ligne!

D'une manière ou d'une autre, je n'avais jamais réalisé que le f"string"raccourci de format existait jusqu'à ce que je voie la réponse de Black Owl Kai.

Matthew Jensen
la source
78 octets par remplacement tuplede(*...,)
Black Owl Kai
Utiliser f"string"rend votre réponse exclusive à Python 3.6+, pour votre information. Beau travail cependant!
connectyourcharger
8

Ruby, 61 59 55 octets

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

Aussi 55 octets:

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

Essayez-le en ligne!

Ceci initialise un compteur à AA-AA000-, l’incrémente nfois (en multipliant une chaîne du code qui le fait par n et evaling), puis déplace les 4 derniers caractères après le 3ème.

Poignée de porte
la source
->n{s=('AA-AA000-'..?Z*9).step.take(n)[-1];s[2]+=s.slice!5,4;s}est plus long mais je me demande s’il est possible de le raccourcir.
Eric Duminil le
En théorie, cela ->n{s=[*'AA-AA000-'..?Z*9][n];s[2]+=s.slice!5,4;s}devrait fonctionner et ne faire que 50 octets de long, mais il génère d'abord toutes les plaques possibles. : - /
Eric Duminil le
1
"s + = s.slice! 3,2" pour 50 octets
GB
Ensuite, cela devrait également fonctionner: 45 octets
GB
7

PHP , 96 84 79 octets

-5 octets grâce aux excellents commentaires d’ Ismael Miguel .

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

Essayez-le en ligne!

Je profite du fait que vous pouvez incrémenter des lettres en PHP! Ainsi AAAA++deviendraient AAABet AAAZ++deviendraient AABA. Je calcule combien de fois les lettres doivent être incrémentées en obtenant une partie entière de input/1000. Puis incrémentez la longueur de quatre caractères à plusieurs reprises et ses deux premiers et deux derniers caractères deviendront automatiquement les côtés gauche et droit de la plaque.

Par exemple, pour entrer le 675999nombre d’incréments de lettres (int)(675999 / 1000) = 675, il AAAAdeviendra AAZZ.

Enfin, le nombre du milieu est calculé par input%1000et tout est imprimé dans le format spécifié à l'aide de printf . %.2simprime les deux premiers caractères de la chaîne, %03uinsère le chiffre à gauche de 3 zéros.

Nuit2
la source
2
@ Elcan Désolé, les problèmes ont été résolus à un coût de 12 octets. J'ai une excuse pour être attaqué par trois chats, pour ma
foutaise
1
Au lieu de %0.2svous pouvez écrire %.2s. Cela vous évite 1 octet. (Petit conseil: si vous souhaitez générer un nombre décimal avec un nombre spécifique de décimales, vous pouvez utiliser %.2f(ou tout autre modificateur) car il fonctionne de la même manière)
Ismael Miguel le
1
@IsmaelMiguel Merci, je ne savais pas que nous pouvions laisser tomber le 0. Edit: en regardant les documentations, il semble que je n’en ai même pas eu besoin au départ: P
Night2
1
Oh, oui, vous pouvez les laisser tomber. En outre, vous pouvez faire $x++^$argn/1e3au lieu de $x++<(0^$argn/1e3)et vous devriez économiser 4 octets. Cela va boucler jusqu’à ($x++^$argn/1e3) === 0, et c’est 0quand $xet $argn/1e3sont le même nombre entier (en utilisant ^va convertir les nombres en entier). Vous pouvez essayer ceci sur sandbox.onlinephpfunctions.com/code/…
Ismael Miguel
1
@IsmaelMiguel Merci encore, idée très intelligente. Vous avez fait cette réponse plus courte que celle de JS et c’est un exploit: P
Night2 le
7

C, 88 86 octets

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

Assez simple, il utilise la division et le module pour extraire les champs, ajoute 'A' pour les lettres afin de les mapper avec des caractères ASCII et le formatage printf pour les nombres.

Essayez-le en ligne!

Sir_Lagsalot
la source
6

Haskell, 85 81 79 77 octets

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

Essayez-le en ligne!

nimi
la source
6

05AB1E , 25 22 20 octets

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

-2 octets (et augmentation des performances en ne générant pas la liste complète) grâce à @Grimy .

Indexation basée sur 0.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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)

La dernière partie ( s₄‰`UèX₄+¦'-.øý) pourrait être I₄÷èI₄+3.£.ý'-ýune alternative à octets identiques:
essayez-la en ligne ou vérifiez tous les cas de test .

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
la source
1
20 avec Au2ããI₄‰`UèX₄+¦'-.øýou Au2ããI₄÷èI₄+3.£'-.øý.
Grimmy le
1
@ Grimy Merci! Et maintenant, il est également beaucoup plus rapide de ne pas générer ni d’indexer dans la liste complète. :)
Kevin Cruijssen le
6

J , 56 49 46 octets

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

Essayez-le en ligne!

-3 octets grâce à FrownyFrog

Le tout n’est que 7 trains imbriqués - si ce n’est pas amusant, c’est quoi?

  ┌─ 226950                                            
  ├─ A.                                                
  │        ┌─ '--'                                     
──┤        ├─ ,                                        
  │        │      ┌─ 7                                 
  └────────┤      ├─ $                                 
           │      │   ┌─ _3                            
           └──────┤   ├─ |.                            
                  │   │    ┌─ 4                        
                  └───┤    │     ┌─ ,                  
                      │    ├─ @ ─┴─ u:                 
                      └────┤                           
                           │     ┌─ 65 48              
                           │     ├─ / ───── +          
                           └─────┤                     
                                 │       ┌─ '4 3#26 10'
                                 └───────┼─ #:         
                                         └─ ]         
Jonas
la source
1
Cool! L'utilisation de la permutation est un bon moyen de formater la chaîne résultante.
Galen Ivanov
1
46
FrownyFrog le
Merci @FrownyFrog!
Jonah
5

R , 101 octets

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)

Essayez-le en ligne!

Fait juste les calculs arithmétiques nécessaires. J'ai enregistré 5 octets en incluant dans le vecteur aune valeur inutile a[4], ce qui me permet de réutiliser le vecteur d'assistance b.

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

Robin Ryder
la source
4

Gelée ,  26  22 octets

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

Un lien monadique acceptant un entier (indexé 1) qui donne une liste de caractères ... Crazy-slow puisqu'il construit toutes les plaques en premier!

Essayez-le en ligne!(ne sera pas complet)
Ou essayez une version avec alphabet réduit (uniquement "ABC" pour les lettres).


Pour le code qui se termine à temps, voici un programme complet de 32 octets (index 0) qui crée la plaque unique à la place en utilisant une décompression de base arithmétique modulaire et numérique:

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

Essaye celui-là!

Jonathan Allan
la source
Il semble manquer les tirets, donc pour l'instant cela ne correspond pas aux règles du défi: P
Elcan
1
Ah, je les ai complètement ignorés comme une sorte de séparateur! Cela fait toute une différence pour ces méthodes :(
Jonathan Allan
Désolé pour ça: c C'est quand même bien de voir ça se faire en Jelly, même sans!
Elcan le
7 byes ajoutés pour les ajouter, à peu près sûr qu'il existe une méthode globale plus courte maintenant ...
Jonathan Allan
Oups, merci @Grimy - peut aussi jouer au golf que par 3 alors que je suis ici: p - Jonathan Allan il y a 1 min
Jonathan Allan
3

Charbon de bois , 33 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

Nθ

Entrez le nombre.

¹

Imprimer a -.

✂I⁺θφ±³

Ajoutez 1000 au nombre, transformez le résultat en chaîne et imprimez les trois derniers chiffres.

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

Divisez le nombre par 1000, puis ajoutez 26⁵, de sorte que la conversion en base personnalisée à l'aide de l'alphabet majuscule entraîne une chaîne de longueur 6, qui est ensuite divisée en paires de lettres.

¹

Imprimer a -.

⊟η

Imprimer la dernière paire de lettres.

M⁹←

Déplacez-vous au début de la plaque d'immatriculation.

⊟η

Imprimez le reste des lettres souhaitées.

Neil
la source
3

Perl 6 , 42 octets

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

Essayez-le en ligne!

Solution Perl 5 du port de Grimy. Lent pour les grandes valeurs d'entrée.

Nwellnhof
la source
3

Excel, 183 167 155 147 octets

-16 octets grâce à @Neil. (6 en utilisantE3 )

-12 octets grâce à @Keeta. ( TRUNCau lieu deQUOTIENT )

-8 octets grâce à @Jonathan Larouche ( INTau lieu de 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))

Concatène 5 parties:

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
la source
Ne MOD(QUOTIENT(A1,1E3),26)fonctionne pas? En outre, pourquoi 1E3pour 1000mais pas 26E3etc?
Neil
Économisez encore plus en supprimant TRUNC et en déplaçant la division à l'intérieur du MOD. = CHAR (65 + A1 / 17576E3) & CHAR (65 + MOD (A1 / 676E3,26)) & "-" & TEXT (MOD (A1,1E3), "000") & "-" et CHAR (65 + MOD (A1 / 26E3,26)) & CHAR (65 + MOD (A1 / 1E3,26)) le ramenant à 127 octets.
Keeta
Je voulais dire enlever QUOTIENT. À l'origine, je proposais de changer le quotient en tronqué avec un / au lieu d'une virgule.
Keeta
@Keeta, votre solution de 127 octets échoue pour certaines valeurs: par exemple 456 975 996->[Z-996-ZZ
Wernisch le
@Keeta, on dirait que CHAR(65+)tronque silencieusement les décimales jusqu'à %.9999997614649. Plus gros que cela est arrondi. Comparez CHAR(65+24.9999997614649)et CHAR(65+24.999999761465).
Wernisch le
2

Propre , 107 octets

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

Essayez-le en ligne!

Définit $ :: Int -> [Char]la n-ième plaque d'immatriculation à index zéro.

Οurous
la source
2

Japt , 21 octets

Obscurément lent! Sérieusement, n'essayez même pas de le lancer!

Un bravo à Kevin pour m'avoir fait comprendre où j'allais mal lorsque je me suis battu pour que cela fonctionne la nuit dernière.

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

Essayez-le - limite la plage de numéros à 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) 
Hirsute
la source
2

Forth (gforth) , 94 octets

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

Essayez-le en ligne!

0 indexé. L'entrée est prise du haut de la pile

Explication du code

\ 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
la source
2

q , 78 octets

{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
griffonner
la source
2

T-SQL, 135 octets

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
la source
1

Python 2 , 88 octets

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

Essayez-le en ligne!

Chas Brown
la source
La sauvegarde par mypetition sous ma réponse peut être appliquée à Python 2 aussi
Black Owl Kai
1

Rouge , 130 127 octets

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

Essayez-le en ligne!

Galen Ivanov
la source
1

Python 3 , 89 octets

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

Essayez-le en ligne!

-1 octet grâce à mypetlion

Black Owl Kai
la source
1
Changer chr(x//26000%26+65)+chr(x//1000%26+65)pour '%c%c'%(x//26000%26+65,x//1000%26+65)enregistrer 1 octet.
mypetlion le
1

MATLAB , 113 octets

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

Explications:

La première ligne définit une fonction qui produira un caractère (de Aà Z), fonction de 2 entrées. Le numéro d'index xà convertir en un numéro de plaque et un entier pqui sera utilisé comme exposant pour 26 (c'est-à-dire 26^p). Cette seconde entrée permet d’ajuster les calculs pour le premier chiffre alphanumérique de la plaque ( p=3) jusqu’au dernier (p=0 ).

Par exemple, pour le deuxième chiffre cyclé toutes les 1000 * 26 * 26 itérations, l'opération: mod(idivide(x,1000*26^2),26)renvoie un index compris entre 0 et 25, qui est ensuite converti en ASCII charen ajoutant 65 (car les index sont 0basés).

La deuxième ligne concatène simplement les caractères ensemble. Chaque caractère alphanumérique est calculé à l'aide de la fonction c(x,p). Les caractères numériques sont simplement calculés à l'aide d'une moduloopération et convertis en chaîne.

Chaque composant de la chaîne composant le numéro de plaque est le suivant:

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) 

Puisque je ne peux pas vous laisser essayer MATLAB en ligne ( edit: en fait, vous pouvez l' essayer en ligne ), je vais laisser les utilisateurs de Matlab la possibilité de vérifier les cas de test:

% 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

les sorties:

     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: Notez que l’option permettant de laisser sprintfou de fprintfprendre en charge la conversion de nombre en caractères est possible. Cela permet de simplifier la fonction c, mais aboutit globalement à quelques octets supplémentaires dans cette implémentation (119 octets):

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
la source
1

C (gcc) , 136 106 105 octets

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

Essayez-le en ligne!

-7 octets de celingcat de solution , avec inspiration supplémentaire -23 par elle

-1 octet de la solution de ceilingcat en remplaçant le par char[]un wchar_t[]casting impliciteint[]

Utilise l'indexation basée sur 0.

Explication / 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
la source
@ceilingcat Merci! En utilisant cette idée, j'ai supprimé les paramètres aet bde la macro et je suis descendu à 106 octets
pizzapants184
0

Python 3 , 161 octets

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

Essayez-le en ligne!

Koishore Roy
la source