Hộp cát

Biển số Pháp

Biển số xe Pháp được xếp theo thứ tự, theo một mẫu số và chữ cái cụ thể:AB-012-CD

Thử thách

Viết chương trình hoặc hàm, cho một số đã cho, xuất ra số biển số giấy phép tiếng Pháp tương ứng . Chương trình của bạn không được xử lý bất kỳ trường hợp đặc biệt nào như được chỉ định trong trang được liên kết. Nó sẽ có thể tạo ra các 26*26*1000*26*26 => 456 976 000tấm đầy đủ có thể, hoặc theo như ngôn ngữ của bạn có thể hỗ trợ.

Hệ thống đánh số như sau:

• AA-000-AA đến AA-999-AA (số tiến hóa trước);
• AA-000-AB đến AA-999-AZ (sau đó là chữ cái cuối cùng bên phải);
• AA-000-BA đến AA-999-ZZ (sau đó là chữ cái đầu tiên bên phải);
• AB-000-AA đến AZ-999-ZZ (sau đó là chữ cái cuối cùng bên trái);
• BA-000-AA đến ZZ-999-ZZ (sau đó là chữ cái đầu tiên bên trái).

Đầu vào

• Chỉ số của số tấm là số nguyên

Đầu ra

• Số biển số xe tương ứng của Pháp

Thông tin thêm

• Chữ cái phải viết hoa
• Bạn có thể sử dụng cả lập chỉ mục dựa trên 0 và dựa trên 1 để tạo các tấm (có nghĩa là AA-000-AA có thể tương ứng 0hoặc 1, giả sử tất cả các trường hợp thử nghiệm khác sử dụng cùng một chỉ mục.

Đây là môn đánh gôn , câu trả lời ngắn nhất trong mọi ngôn ngữ đều thắng!

Các trường hợp thử nghiệm (lập chỉ mục dựa trên 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 (không có dụng cụ bên ngoài), 64

• Lưu 2 byte nhờ @NahuelFouilleul

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

Hãy thử trực tuyến! - mất khoảng 10 giây để chạy qua 7 testcase.

• Dòng # 1 là một phép gán đơn giản của một chuỗi cho một biến
• Dòng # 2 là một mở rộng cú đúp để xây dựng một chuỗi các chuỗi định dạng printf, một chuỗi cho tất cả 456.976 kết hợp chữ cái có thể, với các chữ số chưa được chỉ định. Điều evalnày là cần thiết để đảm bảo mở rộng biến (của x) xảy ra trước khi mở rộng dấu ngoặc.
• Dòng số 3 lập chỉ mục mảng để lấy chuỗi định dạng phù hợp và lấy phần chữ số làm tham số.

Perl 5 (-ap), 47 byte

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

Hãy thử trực tuyến!

PHP , 74 byte

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

Hãy thử trực tuyến!

Python 3 , 79 78 77 byte

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

Hãy thử trực tuyến!

Tôi bằng cách nào đó không bao giờ nhận ra rằng các f"string"phím tắt định dạng tồn tại cho đến khi nhìn thấy câu trả lời của Black Owl Kai.

Ruby, 61 59 55 byte

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

Ngoài ra 55 byte:

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

Hãy thử trực tuyến!

Điều này khởi tạo một bộ đếm tới AA-AA000-, tăng số nlần (bằng cách nhân một chuỗi mã làm như vậy với n và evaling), sau đó di chuyển 4 ký tự cuối cùng sau 3 giây.

PHP , 96 84 79 byte

-5 byte nhờ những bình luận tuyệt vời của Ismael Miguel .

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

Hãy thử trực tuyến!

Tôi tận dụng thực tế là bạn có thể tăng các chữ cái trong PHP! Vì vậy, AAAA++sẽ trở thành AAABvà AAAZ++sẽ trở thành AABA. Tôi tính toán số lần các chữ cái phải được tăng lên bằng cách lấy phần nguyên của input/1000. Sau đó tăng chiều dài bốn ký tự nhiều lần và hai ký tự đầu tiên và hai ký tự cuối cùng của nó sẽ tự động trở thành bên trái và bên phải của tấm.

Ví dụ, đối với đầu vào của 675999số gia tăng chữ cái (int)(675999 / 1000) = 675, do đó AAAAsẽ trở thành AAZZ.

Cuối cùng, số ở giữa được tính theo input%1000và mọi thứ được in ở định dạng đã chỉ định với sự trợ giúp của printf . %.2sin hai ký tự đầu tiên của chuỗi, %03uđệm số ở bên trái với 3 số không.

C, 88 86 byte

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

Khá đơn giản, nó sử dụng phép chia và mô đun để trích xuất các trường, thêm 'A' cho các chữ cái để ánh xạ chúng thành các ký tự ASCII và định dạng printf cho các số.

Hãy thử trực tuyến!

Haskell, 85 81 79 77 byte

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

Hãy thử trực tuyến!

05AB1E , 25 22 20 byte

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

-2 byte (và tăng hiệu suất bằng cách không tạo toàn bộ danh sách) nhờ @Grimy .

Lập chỉ mục dựa trên 0.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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)

Phần cuối cùng ( s₄‰`UèX₄+¦'-.øý) có thể là I₄÷èI₄+3.£.ý'-ýmột thay thế byte bằng nhau:
Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

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 byte

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

Hãy thử trực tuyến!

-3 byte nhờ FrownyFrog

Toàn bộ không có gì ngoài 7 chuyến tàu lồng nhau - nếu điều đó không vui, thì sao?

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

Hãy thử trực tuyến!

Ruby , 51 byte

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

Hãy thử trực tuyến!

R , 101 byte

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)

Hãy thử trực tuyến!

Chỉ cần tính toán số học cần thiết. Tôi đã lưu 5 byte bằng cách đưa vào vectơ amột giá trị vô dụng tại a[4], cho phép tôi sử dụng lại vectơ trợ giúpb .

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

Thạch ,  26  22 byte

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

Một liên kết đơn nguyên chấp nhận một số nguyên (1 chỉ mục) sẽ tạo ra một danh sách các ký tự ... Crazy-Slow vì nó xây dựng tất cả các tấm trước tiên!

Hãy thử trực tuyến!(không hoàn thành)
Hoặc thử phiên bản bảng chữ cái rút gọn (chỉ "ABC" cho các chữ cái).

Đối với mã hoàn thành kịp thời, đây là chương trình đầy đủ 32 byte (được lập chỉ mục 0) tạo ra một tấm thay vì sử dụng giải nén số học và cơ sở số mô-đun:

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

Hãy thử cái này!

APL + THẮNG, 61 byte

Lời nhắc cho số nguyên:

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

Hãy thử trực tuyến! Lịch sự của Dyalog Classic

Than , 33 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｎθ

Nhập số.

¹

In một -.

✂Ｉ⁺θφ±³

Thêm 1000 vào số, sau đó bỏ kết quả thành chuỗi và in ba chữ số cuối.

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

Chia số cho 1000, sau đó thêm 26⁵, do đó, việc chuyển đổi sang cơ sở tùy chỉnh bằng cách sử dụng bảng chữ cái viết hoa dẫn đến một chuỗi có độ dài 6, sau đó được chia thành các cặp chữ cái.

¹

In một -.

⊟η

In cặp chữ cái cuối cùng.

Ｍ⁹←

Di chuyển đến đầu của biển số.

⊟η

In phần còn lại của các chữ cái mong muốn.

Perl 6 , 42 byte

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

Hãy thử trực tuyến!

Giải pháp Perl 5 của cảng Grimy. Chậm cho các giá trị đầu vào lớn.

Excel, 183 167 155 147 byte

-16 byte nhờ @Neil. (6 bằng cách sử dụng E3)

-12 byte nhờ @Keeta. ( TRUNCthay vì QUOTIENT)

-8 byte nhờ @Jonathan Larouche ( INTthay vì 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))

Kết hợp 5 phần:

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

Sạch , 107 byte

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

Hãy thử trực tuyến!

Xác định $ :: Int -> [Char]cho tấm giấy phép không có chỉ số thứ n.

Japt , 21 byte

Rõ ràng là chậm! Nghiêm túc, thậm chí không cố gắng để chạy nó!

Mẹo đội mũ cho Kevin vì đã khiến tôi nhận ra mình đã sai ở đâu khi chiến đấu để làm việc này tối qua.

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

Hãy thử nó - giới hạn phạm vi số 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 byte

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

Hãy thử trực tuyến!

Chỉ số 0. Đầu vào được lấy từ đầu ngăn xếp

Giải thích mã

\ 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 byte

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

Hãy thử trực tuyến!

Màu đỏ , 130 127 byte

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

Hãy thử trực tuyến!

Python 3 , 89 byte

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

Hãy thử trực tuyến!

-1 byte nhờ vào mypetlion

MATLAB , 113 byte

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

Giải thích:

Dòng đầu tiên xác định một hàm sẽ tạo ra một char (từ Ađến Z), hàm của 2 đầu vào. Số chỉ mục xđể chuyển đổi thành số tấm và số nguyên psẽ được sử dụng làm số mũ cho 26 (tức là 26^p). Đầu vào thứ hai này cho phép điều chỉnh các tính toán cho chữ số đầu tiên của chữ số ( p=3) xuống đến chữ số cuối cùng (p=0 ).

Ví dụ, đối với chữ số thứ hai, đã lặp lại sau mỗi 1000 * 26 * 26 lần lặp, thao tác: mod(idivide(x,1000*26^2),26)trả về một chỉ số từ 0 đến 25, sau đó được chuyển đổi thành ASCII charbằng cách thêm 65 (vì chỉ mục là0 dựa trên)

Dòng thứ hai chỉ đơn giản là ghép các ký tự lại với nhau. Mỗi ký tự chữ và số được tính với việc sử dụng hàm c(x,p), ký tự số được tính đơn giản bằng mộtmodulo thao tác và được chuyển đổi thành chuỗi.

Mỗi thành phần của chuỗi soạn thảo số tấm như sau:

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) 

Vì tôi không thể cho phép bạn thử MATLAB trực tuyến ( chỉnh sửa: thực sự bạn có thể thử trực tuyến ), tôi sẽ cho phép người dùng MATLAB xác minh các trường hợp kiểm tra:

% 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

đầu ra:

     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

Biến thể: Lưu ý rằng tùy chọn cho phép sprintfhoặc fprintfchăm sóc số để chuyển đổi ký tự là có thể. Nó cho phép đơn giản hóa chức năng c, nhưng tổng thể dẫn đến một vài byte nữa trong triển khai này (119 byte):

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 byte

{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 byte

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

Hãy thử trực tuyến!

-7 byte từ giải pháp của celingcat , với thêm -23 lấy cảm hứng từ nó

-1 byte từ giải pháp của trần nhà bằng cách thay đổi char[]thành một kiểu wchar_t[]ngầm định thànhint[]

Sử dụng lập chỉ mục dựa trên 0.

Giải thích / 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 byte

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

Hãy thử trực tuyến!

Kotlin , 93 byte

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

Hãy thử trực tuyến!

Python 3 , 161 byte

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

Hãy thử trực tuyến!