Kum havuzu

Fransız Plakaları

Fransız plakaları , belirli bir sayı ve harf şeklini izleyerek sıralı olarak gelir:AB-012-CD

Meydan okuma

Belirli bir sayı için, ilgili fransız plaka numarasını veren bir program veya işlev yazın . Programınız, link verilen sayfada belirtilen özel durumlarla ilgilenmemelidir. 26*26*1000*26*26 => 456 976 000Mümkün olan tüm plakaları veya dilinizin destekleyebildiği ölçüde üretebilmesi gerekir .

Numaralandırma sistemi aşağıdaki gibidir:

• AA-000-AA ila AA-999-AA (ilk önce sayılar artar);
• AA-000-AB ila AA-999-AZ (sonra sağdaki son harf);
• AA-000-BA ila AA-999-ZZ (sonra sağdaki ilk harf);
• AB-000-AA ila AZ-999-ZZ (sonra soldaki son harf);
• BA-000-AA ila ZZ-999-ZZ (sonra soldaki ilk harf).

Giriş

• Plaka sayısının tamsayı olarak gösterilmesi

Çıktı

• İlgili fransız plaka numarası

Ek bilgi

• Harfler büyük olmalı
• Plakları oluşturmak için hem 0 hem de 1 tabanlı indekslemeyi kullanabilirsiniz (AA-000-AA'nın karşılık gelebileceği 0veya 1tüm diğer test durumlarının aynı endekslemeyi kullandığı varsayımıyla).

Bu kod golf , her dilde kazanılan en kısa cevap!

Test durumları (0 tabanlı dizin oluşturma)

          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

Saf Bash (harici dosya yok), 64

• @NahuelFouilleul sayesinde 2 bayt kurtarıldı

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

Çevrimiçi deneyin! - 7 test evresinden geçmek yaklaşık 10 saniye sürüyor.

• 1. satır bir dizgenin değişkene basit bir atamasıdır.
• Satır # 2, henüz belirtilmemiş olan 456,976 olası harf kombinasyonunun tümü için bir tane printf formatı dizgisi dizisi oluşturmak için kullanılan bir ayraçtır. eval(X) bir değişken genleşme ayracı genişleme önce meydana sağlamak için gereklidir.
• Satır # 3, uygun format dizesini almak için diziyi dizine alır ve basamak bölümünü parametre olarak alır.

Perl 5 (-ap), 47 bayt

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

Çevrimiçi deneyin!

PHP , 74 bayt

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

Çevrimiçi deneyin!

Python 3 , 79 78 77 bayt

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

Çevrimiçi deneyin!

Bir şekilde f"string"Black Owl Kai'nin cevabını görene kadar format kısayolunun var olduğunu hiç anlamadım.

Ruby, 61 59 55 bayt

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

Ayrıca 55 bayt:

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

Çevrimiçi deneyin!

Bu bir sayacı başlatır AA-AA000-, nzamanını arttırır ( bunu yapan kodun bir dizesini n ve evaling ile çarparak ) ve ardından 3.nden sonraki son 4 karakteri taşır.

PHP , 96 84 79 bayt

-5 byte Ismael Miguel 'in güzel yorumlarına teşekkürler .

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

Çevrimiçi deneyin!

PHP'deki harfleri artırabileceğiniz gerçeğinden faydalanıyorum! Böylece AAAA++olur AAABve AAAZ++olur AABA. Tamsayı bir parçası alarak harflerin kaç kez artırılması gerektiğini hesaplarım input/1000. Ardından dört karakter uzunluğunu artırın, ilk iki ve son iki karakter otomatik olarak plakanın sol ve sağ tarafı olacak.

Örneğin 675999harf artışlarının sayısının girişi için (int)(675999 / 1000) = 675, öyle AAAAolacaktır AAZZ.

Son olarak, orta sayı hesaplanır input%1000ve her şey printf yardımı ile belirtilen formatta yazdırılır . %.2sdizginin ilk iki karakterini yazdırır %03u, soldaki sayıyı 3 sıfır ile doldurur.

C, 88 86 bayt

# tanım d (b) a / b /% 1000 26 + 65
f (a) {printf ( "% c% c% 03d-%% c c" d (17576), d (676), bir% 1000, D (26), d (1));}

Oldukça basit, alanları çıkarmak için bölme ve modülleme kullanır, harfleri ASCII karakterlerine eşlemek için harflere 'A' ve sayılar için printf biçimlendirmesi kullanır.

Çevrimiçi deneyin!

Haskell, 85 81 79 77 bayt

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

Çevrimiçi deneyin!

05AB1E , 25 22 20 bayt

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

-2 bayt (ve tüm listeyi oluşturmayarak performansı arttırdı) @Grimy sayesinde .

0 tabanlı indeksleme.

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

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)

Son bölüm ( s₄‰`UèX₄+¦'-.øý) I₄÷èI₄+3.£.ý'-ýeşit baytlık bir alternatif olabilir:
Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

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 bayt

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

Çevrimiçi deneyin!

FrownyFrog sayesinde -3 bayt

Her şey 7 iç içe geçmiş trenden başka bir şey değil - eğer eğlenceli değilse, nedir?

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

JavaScript (Node.js) , 82 bayt

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

Çevrimiçi deneyin!

Ruby , 51 bayt

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

Çevrimiçi deneyin!

R , 101 bayt

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)

Çevrimiçi deneyin!

Sadece gerekli aritmetik hesaplamaları yapar. Yardımcı vektörü yeniden kullanmama izin vererek vektöre aişe yaramaz bir değer ekleyerek 5 bayt kurtardım .a[4]b

Örneğin ikinci karakteri ( Bin AB-012-CD) düşünün . Bu karakter her değişiyor$26\times26\times1000=676\,000$nn %/% 676000 %% 26%/%%%

Jöle ,  26  22 bayt

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

Karakter listesini veren bir tamsayı (1-indeksli) kabul eden bir monadik Link ... Tüm plakaları ilk oluşturduğu için deli-yavaş!

Çevrimiçi deneyin! (tamamlanmış olmaz)
Veya azaltılmış alfabe sürümünü deneyin(harfler için sadece "ABC").

Zamanında tamamlanan kod için burada modüler aritmetik ve sayısal baz dekompresyonu kullanarak tek plakayı oluşturan 32 bayt tam program (0 indeksli):

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

Bunu dene!

APL + WIN, 61 bayt

Tamsayı için ister:

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

Çevrimiçi deneyin! Dyalog Classic'in İzniyle

Kömür , 33 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

Ｎθ

Numarayı giriniz.

¹

Bir yazdırma -.

✂Ｉ⁺θφ±³

Sayıya 1000 ekleyin, sonucu dizeye alın ve son üç basamağı yazdırın.

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

Sayıyı 1000'e bölün ve ardından 26⁵ ekleyin, böylece büyük harfli alfabe kullanarak özel tabana dönüştürme işlemi daha sonra harf çiftlerine bölünmüş olan 6 uzunluğunda bir dizeyle sonuçlanır.

¹

Bir yazdırma -.

⊟η

Son harf çiftini yazdır.

Ｍ⁹←

Plaka numarasının başına gidin.

⊟η

İstediğiniz harflerin kalanını yazdırın.

Perl 6 , 42 bayt

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

Çevrimiçi deneyin!

Grimy'nin Perl 5 çözümü Limanı. Büyük giriş değerleri için yavaş.

Excel, 183 167 155 147 bayt

@Neil sayesinde -16 bayt. (6 kullanarak E3)

@Keeta sayesinde -12 bayt. ( TRUNCyerine QUOTIENT)

@Jonathan Larouche sayesinde -8 bayt ( INTyerine 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))

5 bölüm birleştirir:

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

Temiz , 107 bayt

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

Çevrimiçi deneyin!

N. $ :: Int -> [Char]Sıfıra indeksli plakanın verilmesini tanımlar .

Japt , 21 bayt

Müstehcen yavaş! Cidden, onu çalıştırmayı bile deneme!

Dün gece bu işi yapmak için savaşırken yanlış yaptığım yeri anlamamı sağladığı için Kevin'in şapkasının ipucu .

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

Deneyin - sayı aralığını sınırlar 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) 

İleri (gforth) , 94 bayt

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

Çevrimiçi deneyin!

0 endeksli. Giriş yığının üstünden alınır

Kod açıklaması

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

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,8 bayt

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

Çevrimiçi deneyin!

Kırmızı , 130 127 bayt

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

Çevrimiçi deneyin!

Python 3 , 89 bayt

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

Çevrimiçi deneyin!

Mypetlion sayesinde -1 bayt

MATLAB , 113 bayt

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

açıklamalar:

İlk hat (bir kömürü üretecek bir işlev tanımlamak Aiçin Z), 2 girişlerin işlevini. xBir plaka numarasına dönüştürülecek indeks numarası ve p26 (yani 26^p) için üs olarak kullanılacak bir tam sayı . Bu ikinci giriş, ilk alfanümerik plaka basamağının hesaplamalarını ( p=3) aşağıya ( ) doğru ayarlamanızı sağlar p=0.

Örneğin, ikinci basamak için, her 1000 * 26 * 26 yinelemede çevrilmiş, işlem: mod(idivide(x,1000*26^2),26)0 ile 25 arasında bir dizin döndür, daha sonra char65 ekleyerek bir ASCII'ye dönüştürülür (dizin 0temellidir)

İkinci satır basitçe karakterleri bir araya getirir. Her alfanümerik karakter, fonksiyon kullanılarak hesaplanır c(x,p), sayısal karakter bir moduloişlemle basit bir şekilde hesaplanır ve dizgeye dönüştürülür.

Plaka numarasını oluşturan dizgenin her bileşeni aşağıdaki gibidir:

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) 

MATLAB'ı çevrimiçi olarak denemenize izin veremediğimden ( düzenleme: aslında çevrimiçi deneyebilirsiniz ), MATLAB kullanıcılarının sınama durumlarını doğrulama olanağına sahip olacağım:

% 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

çıktılar:

     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

Varyant: Sayıya karakter dönüştürmeye izin verme sprintfveya fprintfonunla ilgilenme seçeneğinin mümkün olduğunu unutmayın. İşlevin basitleştirilmesine izin verir c, ancak genel olarak bu uygulamada birkaç bayt ile sonuçlanır (119 bayt):

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 bayt

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

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

Çevrimiçi deneyin!

-7 gelen bayt celingcat 'in çözeltisi ilave ile, -23 bunu ilham

Ceilingcat en -1 bayt çözeltisi değiştirerek char[]a wchar_t[]dolaylı dökümint[]

0 tabanlı endeksleme kullanır.

Açıklama / 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 bayt

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

Çevrimiçi deneyin!

Kotlin , 93 bayt

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

Çevrimiçi deneyin!

Python 3 , 161 bayt

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

Çevrimiçi deneyin!