모래 상자

프랑스 번호판

프랑스어 번호판 은 숫자와 문자의 특정 패턴에 따라 순차적으로 제공됩니다.AB-012-CD

도전

주어진 번호에 해당하는 프랑스어 번호판 번호를 출력하는 프로그램 또는 기능을 작성하십시오 . 귀하의 프로그램은 링크 된 페이지에 명시된 특별한 경우를 처리해서는 안됩니다. 26*26*1000*26*26 => 456 976 000가능한 모든 판 을 만들 수 있거나 언어가 지원할 수있는 한 가능해야합니다.

번호 시스템은 다음과 같습니다.

• AA-000-AA에서 AA-999-AA까지 (숫자가 먼저 진화);
• AA-000-AB에서 AA-999-AZ까지 (오른쪽의 마지막 글자);
• AA-000-BA에서 AA-999-ZZ (오른쪽의 첫 번째 글자);
• AB-000-AA에서 AZ-999-ZZ (왼쪽의 마지막 글자);
• BA-000-AA에서 ZZ-999-ZZ (왼쪽의 첫 글자).

입력

• 정수로 판 번호의 색인

산출

• 해당 프랑스 번호판 번호

추가 정보

• 문자는 대문자 여야합니다
• 0 기반 및 1 기반 인덱싱을 사용하여 플레이트를 생성 할 수 있습니다 ( 다른 모든 테스트 사례가 동일한 인덱싱을 사용한다고 가정하면 AA-000-AA는 0또는에 해당 할 수 있음을 의미 함) 1.

이것은 모든 언어 승리에서 가장 짧은 코드 골프입니다 !

테스트 사례 (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

순수 배쉬 (외부 유틸리티 없음), 64

• @NahuelFouilleul 덕분에 2 바이트 절약

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

온라인으로 사용해보십시오! -7 개의 테스트 케이스를 실행하는 데 약 10 초가 걸립니다.

• 라인 # 1은 변수에 문자열을 간단히 할당하는 것입니다
• 2 번 줄은 456,976 개의 가능한 문자 조합에 대해 하나씩 숫자를 지정하지 않은 printf 형식 문자열의 배열을 만들기위한 중괄호 확장입니다. 은 eval(는 x) 가변 확장 중괄호 확장 전에 발생되도록 할 필요가있다.
• 3 번 줄은 배열을 인덱싱하여 적절한 형식 문자열을 가져오고 숫자 부분을 매개 변수로 사용합니다.

Perl 5 (-ap), 47 바이트

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

온라인으로 사용해보십시오!

PHP , 74 바이트

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

온라인으로 사용해보십시오!

파이썬 3 , 79 78 77 바이트

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

온라인으로 사용해보십시오!

f"string"Black Owl Kai의 대답을 볼 때까지 형식 바로 가기가 존재 한다는 것을 어떻게 든 깨닫지 못했습니다 .

루비, 61 59 55 바이트

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

또한 55 바이트 :

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

온라인으로 사용해보십시오!

이렇게하면 카운터가로 초기화되고 시간이 AA-AA000-증가하고 n(코드에 n과 evaling 을 곱한 문자열이 곱 해짐) 3 번째 이후 마지막 4자가 이동합니다.

PHP , 96 84 79 바이트

Ismael Miguel 의 훌륭한 의견 덕분에 -5 바이트 .

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

온라인으로 사용해보십시오!

PHP에서 글자를 증가시킬 수 있다는 사실을 이용합니다! 그래서 AAAA++이 될 것입니다 AAAB및 AAAZ++될 것입니다 AABA. 정수 부분을 가져 와서 문자를 몇 번이나 증가시켜야하는지 계산합니다 input/1000. 그런 다음 네 글자 길이를 여러 번 늘리면 첫 두 글자와 마지막 두 글자가 자동으로 판의 왼쪽과 오른쪽이됩니다.

의 입력 예를 들어 675999편지 단위의 숫자가 (int)(675999 / 1000) = 675, 그렇게 AAAA될 것입니다 AAZZ.

마지막으로 중간 숫자가 계산되고 printf의input%1000 도움으로 모든 것이 지정된 형식으로 인쇄됩니다 . 문자열의 처음 두 문자를 인쇄 하고 왼쪽의 숫자를 3으로 채 웁니다.%.2s%03u

C, 88 86 바이트

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

아주 간단합니다. 분할과 계수를 사용하여 필드를 추출하고 문자에 'A'를 추가하여 ASCII 문자에 매핑하고 숫자의 printf 형식을 지정합니다.

온라인으로 사용해보십시오!

하스켈, 85 81 79 77 바이트

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

온라인으로 사용해보십시오!

05AB1E , 25 22 20 바이트

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

@Grimy 덕분에 -2 바이트 (및 전체 목록을 생성하지 않음으로써 성능이 향상됨) .

0 기반 인덱싱

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

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)

마지막 부분 ( s₄‰`UèX₄+¦'-.øý)은 I₄÷èI₄+3.£.ý'-ý같은 바이트 대안 이 될 수 있습니다 .
온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

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 바이트

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

온라인으로 사용해보십시오!

FrownyFrog 덕분에 -3 바이트

모든 것이 7 개의 중첩 된 열차 일뿐입니다. 재미가 없다면 무엇입니까?

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

자바 스크립트 (Node.js) , 82 바이트

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

온라인으로 사용해보십시오!

루비 , 51 바이트

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

온라인으로 사용해보십시오!

R , 101 바이트

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)

온라인으로 사용해보십시오!

필요한 산술 계산 만 수행하십시오. a에 쓸모없는 값을 벡터에 포함시켜 5 바이트를 절약 a[4]하여 도우미 벡터를 재사용 할 수있었습니다 b.

예를 들어 두 번째 문자 ( Bin AB-012-CD)를 고려하십시오 . 그 캐릭터는 마다 변경됩니다$26\times26\times1000=676\,000$nn %/% 676000 %% 26%/%%%

젤리 ,  26  22 바이트

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

문자 목록을 생성하는 정수 (1 색인)를 허용하는 모나드 링크 ... 모든 플레이트를 먼저 빌드하기 때문에 미친 듯이 느립니다!

온라인으로 사용해보십시오! (완료되지 않음)
또는 알파벳을 줄여서 사용 하십시오 (문자에 대해서는 "ABC"만).

적시에 완료되는 코드의 경우 모듈 식 산술 및 숫자 기반 압축 해제를 사용하여 단일 플레이트를 생성하는 32 바이트 풀 프로그램 (0 인덱싱)이 있습니다.

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

이거 한번 해봐!

APL + WIN, 61 바이트

정수에 대한 프롬프트 :

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

온라인으로 사용해보십시오! Dyalog Classic 제공

숯 , 33 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

Ｎθ

숫자를 입력하십시오.

¹

인쇄 a -.

✂Ｉ⁺θφ±³

숫자에 1000을 더한 다음 결과를 문자열로 변환하고 마지막 세 자리를 인쇄하십시오.

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

숫자를 1000으로 나눈 다음 26 add를 더하여 대문자 알파벳을 사용하여 사용자 정의 기준으로 변환하면 길이가 6 인 문자열이되고 문자 쌍으로 분할됩니다.

¹

인쇄 a -.

⊟η

마지막 글자를 인쇄하십시오.

Ｍ⁹←

번호판의 시작 부분으로 이동하십시오.

⊟η

원하는 나머지 글자를 인쇄하십시오.

펄 6 , 42 바이트

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

온라인으로 사용해보십시오!

Grimy 포트 Perl 5 솔루션. 큰 입력 값의 경우 속도가 느립니다.

엑셀, 183 167 155 147 바이트

@Neil 덕분에 -16 바이트 (6을 사용하여 E3)

@Keeta 덕분에 -12 바이트 ( TRUNC대신 QUOTIENT)

-8 (@ 조나단 로슈 덕분에 바이트 INT대신 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 개 부품을 연결합니다 :

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

클린 , 107 바이트

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

온라인으로 사용해보십시오!

$ :: Int -> [Char]n 번째 0 인덱스 번호판 제공을 정의합니다 .

Japt , 21 바이트

당연히 느리다! 진지하게, 그것을 실행하려고하지 마십시오!

어제 밤에이 일을하기 위해 싸우고있을 때 내가 잘못 가고있는 곳을 깨닫게 해준 Kevin 의 모자 끝 .

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

사용해보십시오 -숫자 범위를 제한합니다 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) 

넷째 ( 94 번째) , 94 바이트

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

온라인으로 사용해보십시오!

인덱스가 0입니다. 스택 맨 위에서 입력을 가져옵니다.

코드 설명

\ 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 바이트

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

파이썬 2 , 88 바이트

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

온라인으로 사용해보십시오!

레드 , (130) 127 바이트

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

온라인으로 사용해보십시오!

파이썬 3 , 89 바이트

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

온라인으로 사용해보십시오!

mypetlion 덕분에 -1 바이트

MATLAB , 113 바이트

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

설명 :

첫 번째 줄 은 2 개의 입력 기능인 char (에서 Ato Z)을 생성하는 함수를 정의합니다 . x플레이트 번호로 변환 할 인덱스 번호 및 정수p 26의 지수로 사용될 (즉, 26^p). 이 두 번째 입력을 통해 첫 번째 영숫자 플레이트 숫자 ( p=3) 의 계산을 마지막 숫자 ( )로 조정할 수 p=0있습니다.

예를 들어, 두 번째 숫자의 경우 1000 * 26 * 26 반복마다 사이클이 수행됩니다. mod(idivide(x,1000*26^2),26) 0과 25 사이의 색인을 리턴 한 다음 char65를 추가 하여 ASCII로 변환합니다 (인덱스가 0기반 하기 때문에 )

두 번째 줄은 단순히 문자를 연결합니다. 각 영숫자 문자는 함수를 사용하여 계산됩니다.c(x,p) 숫자 문자는 단순히 연산으로 계산 modulo되고 문자열로 변환됩니다.

플레이트 번호를 구성하는 문자열의 각 구성 요소는 다음과 같습니다.

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을 온라인으로 시험해 볼 수 없기 때문에 ( 편집 : 실제로 온라인으로 시험해 볼 수 있음) MATLAB 사용자가 테스트 사례를 확인할 수 있도록합니다.

% 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

출력 :

     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

변형 : 숫자 대 문자 변환 을 허용 sprintf하거나 fprintf처리 하는 옵션 이 가능합니다. 함수를 단순화 할 수 c있지만이 구현에서는 전체적으로 몇 바이트가 더 걸립니다 (119 바이트).

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 바이트

{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 바이트

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

온라인으로 사용해보십시오!

celingcat 의 솔루션 에서 -7 바이트 , 추가 -23에서 영감을 얻음

ceilingcat의 -1 바이트 솔루션 을 변경하여 char[]A를 wchar_t[]암시 적으로 캐스팅int[]

0 기반 인덱싱을 사용합니다.

설명 / 비 골프 :

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

줄리아 1.0 , 86 바이트

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

온라인으로 사용해보십시오!

코 틀린 , 93 바이트

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

온라인으로 사용해보십시오!

파이썬 3 , 161 바이트

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

온라인으로 사용해보십시오!