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

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.

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!

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.

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.

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.

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!

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!

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)

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

JavaScript (Node.js) , 82 octets

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

Essayez-le en ligne!

Ruby , 51 octets

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

Essayez-le en ligne!

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

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à!

APL + WIN, 61 octets

Invites pour un entier:

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

Essayez-le en ligne! Gracieuseté de Dyalog Classic

Charbon de bois , 33 octets

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

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

Ｎθ

Entrez le nombre.

¹

Imprimer a -.

✂Ｉ⁺θφ±³

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

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

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.

Ｍ⁹←

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

⊟η

Imprimez le reste des lettres souhaitées.

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.

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

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.

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) 

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

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

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

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!

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!

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

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

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

Julia 1.0 , 86 octets

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

Essayez-le en ligne!

Kotlin , 93 octets

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

Essayez-le en ligne!

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!