फ्रेंच लाइसेंस प्लेट

41

सैंडबॉक्स

फ्रेंच लाइसेंस प्लेट्स

फ्रेंच लाइसेंस प्लेट एक क्रमबद्ध क्रम में आती हैं, संख्या और अक्षरों के एक विशिष्ट पैटर्न के बाद: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
code-golf  string  number  base-conversion 
— Elcan
स्रोत
2
यहां कुछ और आवश्यकताएं हैं, सीधे विकिपीडिया से, यदि आप एक कठिन बदलाव पैदा करना चाहते हैं: "यह आंकड़ा तीन अक्षरों को शामिल करता है जो उपयोग नहीं किए जाते हैं: I, O और U, क्रमशः उन्हें 1, 0 और V के साथ भ्रमित किया जा सकता है। यह एसएस संयोजन को भी शामिल नहीं करता है क्योंकि यह नाजी संगठन और डब्ल्यूडब्ल्यू की याद दिलाता है जो पहले अक्षरों में समूह है क्योंकि यह एक अस्थायी प्लेट है। "
— एरिक डुमिनील
4
@EricDuminil मैंने उद्देश्यपूर्ण रूप से इसे बाहर कर दिया क्योंकि यह चुनौती पर अनजाने बाधाओं को जोड़ता था। लेकिन यह सच है कि यह करना दिलचस्प हो सकता है, लेकिन "बोनस अंक" के साथ भी, मुझे संदेह है कि यह इन नियमों को लागू करने के लायक होगा
— एलकैन

जवाबों:

17

शुद्ध बैश (कोई बाहरी बर्तन नहीं), 64

  • 2 बाइट्स ने @NahuelFouilleul को धन्यवाद दिया
x={A..Z}
eval f=($x$x-%03d-$x$x)
printf ${f[$1/1000]} $[$1%1000]

इसे ऑनलाइन आज़माएं! - 7 टेस्टिकल्स से अधिक चलने के लिए लगभग 10s लगते हैं।

  • लाइन # 1 एक चर के लिए एक सरल असाइनमेंट है
  • लाइन # 2 प्रिंटफ फॉर्मेट स्ट्रिंग्स की एक सरणी बनाने के लिए एक ब्रेस विस्तार है, सभी 456,976 संभावित पत्र संयोजनों के लिए एक, अंकों के साथ अभी तक निर्दिष्ट नहीं है। evalसुनिश्चित करने के लिए (एक्स का) अलग-अलग विस्तार ब्रेस विस्तार से पहले होता है की आवश्यकता है।
  • पंक्ति # 3 उपयुक्त प्रारूप स्ट्रिंग प्राप्त करने के लिए सरणी को अनुक्रमित करती है और अंकों को उसके पैरामीटर के रूप में लेती है।
— डिजिटल आघात
स्रोत
1
— नहुएल फौइउल
13

पर्ल 5 (-प), 47 बाइट्स

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

इसे ऑनलाइन आज़माएं!

PHP , 74 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— ग्रिमी
स्रोत
2
PHP के लिए +1, मुझे पता था कि हम PHP में अक्षरों को बढ़ा सकते हैं, लेकिन मुझे नहीं पता था कि हम अक्षरों और अंकों के संयोजन को बढ़ा सकते हैं। PHP मुझे हर दिन हैरान करती है! और धन्यवाद मैंने कुछ नया सीखा।
— रात 2
8

पायथन 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"ब्लैक आउल काई का उत्तर देखने तक प्रारूप शॉर्टकट मौजूद है।

— मैथ्यू जेन्सेन
स्रोत
78 बाइट्स द्वारा प्रतिस्थापित tupleकरके(*...,)
— ब्लैक उल्लू काई
उपयोग करने f"string"से आपका उत्तर Python 3.6+ अनन्य हो जाता है, बस इसलिए आप जागरूक हैं। हालांकि अच्छा काम!
— संयोजकचर
8

रूबी, 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 वर्णों को स्थानांतरित करता है।

— Doorknob
स्रोत
->n{s=('AA-AA000-'..?Z*9).step.take(n)[-1];s[2]+=s.slice!5,4;s}अब है, लेकिन मुझे आश्चर्य है कि अगर इसे छोटा करना संभव है।
— एरिक डुमिनील
सिद्धांत रूप में, ->n{s=[*'AA-AA000-'..?Z*9][n];s[2]+=s.slice!5,4;s}काम करना चाहिए और केवल 50 बाइट्स लंबा है, लेकिन यह पहले हर संभव प्लेट उत्पन्न करता है। : - /
— एरिक डुमिनील
1
50 बाइट्स के लिए "s + = s.slice! 3,2"
— जीबी
फिर यह भी काम करना चाहिए: 45 बाइट्स
— जीबी
7

PHP , 96 84 79 बाइट्स

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

अंत में, मध्य संख्या की गणना की जाती है input%1000और सब कुछ प्रिंटफ की मदद से निर्दिष्ट प्रारूप में मुद्रित किया जाता है । %.2sस्ट्रिंग के पहले दो वर्णों को प्रिंट करता है, %03uबाईं ओर की संख्या को 3 शून्य के साथ रखता है।

— Night2
स्रोत
2
@ एलकान क्षमा करें, 12 बाइट्स की लागत पर मुद्दों को तय किया। मेरे पास गड़बड़ करने के लिए तीन बिल्लियों द्वारा हमला किए जाने का एक बहाना है: पी
— नाइट 2
1
इसके बजाय %0.2sआप लिख सकते हैं %.2s। जो आपको 1 बाइट बचाता है। (एक छोटी सी टिप के रूप में: यदि आप एक दशमलव संख्या को दशमलव स्थानों की एक विशिष्ट संख्या के साथ आउटपुट करना चाहते हैं, तो आप कर सकते हैं %.2f(या कोई अन्य संशोधक) जैसा कि यह उसी तरह काम करता है)
— इस्माइल मिगुएल
1
@IsmaelMiguel धन्यवाद, पता नहीं था कि हम छोड़ सकते हैं 0। संपादित करें: दस्तावेज़ों को देखते हुए, ऐसा लगता है कि मुझे पहली जगह पर भी इसकी आवश्यकता नहीं थी: पी
— नाइट 2
1
ओह, हाँ, आप उन लोगों को छोड़ सकते हैं। इसके अलावा, आप इसके $x++^$argn/1e3बजाय कर सकते हैं $x++<(0^$argn/1e3)और आपको 4 बाइट्स बचाने चाहिए। हो जाएगा ताकि पाश जब तक ($x++^$argn/1e3) === 0है, और यह है 0जब $xऔर $argn/1e3एक ही हैं पूर्णांक संख्या (का उपयोग कर ^पूर्णांक तक संख्या डाली जाएगा)। आप इसे sandbox.onlinephpfunctions.com/code/…
— Ismael Miguel
1
@IsmaelMiguel फिर से धन्यवाद, बहुत चतुर विचार। आपने इस उत्तर को JS एक से कम कर दिया है और यह एक उपलब्धि है: P
— Night2
7

सी, 88 86 बाइट्स

# डेफ़िन डी (बी) ए / बी / १०००% २६ + ६५
च (क) {printf ( "% c% ग% 03d-% ग% c", घ (17,576), डी (676), एक% से लेकर 1000, डी (26), डी (1));}

बहुत ही सरल, यह खेतों को निकालने के लिए विभाजन और मापांक का उपयोग करता है, अक्षरों के लिए 'ए' को एएससीआईआई के पात्रों के लिए मैप करने के लिए जोड़ता है, और संख्याओं के लिए प्रिंटफ़ स्वरूपण करता है।

इसे ऑनलाइन आज़माएं!

— Sir_Lagsalot
स्रोत
6

05AB1E , 25 22 20 बाइट्स

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

-2 बाइट्स (और पूरी लिस्ट न बनाकर परफॉर्मेंस बढ़ाया ) @Grimy की बदौलत ।

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)
— केविन क्रूज़सेन
स्रोत
1
20 के साथ Au2ããI₄‰`UèX₄+¦'-.øýया Au2ããI₄÷èI₄+3.£'-.øý।
— ग्रिम्मी
1
@ ग्रैमी थैंक्स! और अब यह पूरी सूची में उत्पन्न नहीं होने और अनुक्रमण द्वारा बहुत तेज है। :)
— केविन क्रूज़सेन
6

जे , 56 49 46 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-3 बाइट्स FrownyFrog के लिए धन्यवाद

पूरी बात 7 नेस्टेड ट्रेनों के अलावा कुछ भी नहीं है - अगर यह मजेदार नहीं है, तो क्या है?

  ┌─ 226950                                            
  ├─ A.                                                
  │        ┌─ '--'                                     
──┤        ├─ ,                                        
  │        │      ┌─ 7                                 
  └────────┤      ├─ $                                 
           │      │   ┌─ _3                            
           └──────┤   ├─ |.                            
                  │   │    ┌─ 4                        
                  └───┤    │     ┌─ ,                  
                      │    ├─ @ ─┴─ u:                 
                      └────┤                           
                           │     ┌─ 65 48              
                           │     ├─ / ───── +          
                           └─────┤                     
                                 │       ┌─ '4 3#26 10'
                                 └───────┼─ #:         
                                         └─ ]
— जोनाह
स्रोत
1
ठंडा! परिणामी स्ट्रिंग को प्रारूपित करने के लिए क्रमपरिवर्तन का उपयोग करना एक अच्छा तरीका है।
— गैलेन इवानोव
1
46
— फ्रॉन्फ्रोग में
धन्यवाद @FrownyFrog!
— योना
5

आर , 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।

उदाहरण के लिए दूसरे चरित्र ( Bइन AB-012-CD) पर विचार करें । यही कारण है कि चरित्र बदल जाता है हर प्लेटें, इसलिए निवेश के लिए कि चरित्र का मूल्य है वर्णमाला, जहां की वें पत्र विभाजन पूर्णांक है और आर में मापांक अन्य पात्रों के परिकलन भी इसी तरह कर रहे हैं।26×26×1000=676000nn %/% 676000 %% 26%/%%%

— रॉबिन राइडर
स्रोत
4

जेली ,  26  22 बाइट्स

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

एक मोनडिक लिंक जो एक पूर्णांक (1-अनुक्रमित) को स्वीकार करता है जो वर्णों की एक सूची देता है ... पागल-धीमा चूंकि यह सभी प्लेटों को पहले बनाता है!

इसे ऑनलाइन आज़माएं! (पूरा नहीं)
या एक कम वर्णमाला संस्करण (केवल "एबीसी" अक्षरों के लिए) का प्रयास करें।

कोड के लिए जो समयबद्ध तरीके से पूरा होता है यहां एक 32 बाइट पूर्ण-प्रोग्राम (0-अनुक्रमित) है जो मॉड्यूलर अंकगणितीय और संख्यात्मक आधार विघटन का उपयोग करने के बजाय एकल प्लेट बनाता है:

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

इसको आजमाओ!

— जोनाथन एलन
स्रोत
ऐसा लगता है कि डैश अब याद नहीं है, इसलिए अब यह चुनौती के नियमों में फिट नहीं है: पी
— एलकैन
1
आह, मैंने उन्हें किसी तरह के विभाजक के रूप में पूरी तरह से नजरअंदाज कर दिया! इन विधियों के लिए काफी अंतर बनाता है :(
— जोनाथन एलन
इसके बारे में क्षमा करें: सी जेली में इसे देखने के लिए अभी भी बहुत अच्छा है, बिना भी!
— एलकैन
उन्हें जोड़ने के लिए 7 बाइट्स जोड़े, बहुत यकीन है कि अब एक छोटी समग्र विधि है ...
— जोनाथन एलन
उफ़, धन्यवाद @Grimy - भले ही मैं यहाँ हूँ कि 3 तक गोल्फ हो सकता है: p - जोनाथन एलन 1 मिनट पहले
— जोनाथन एलन
3

चारकोल , 33 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｎθ

नंबर इनपुट करें।

¹

प्रिंट करें -।

✂Ｉ⁺θφ±³

संख्या में 1000 जोड़ें, फिर परिणाम को स्ट्रिंग करें, और अंतिम तीन अंक प्रिंट करें।

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

संख्या को 1000 से विभाजित करें, फिर 26⁵ जोड़ें, इसलिए अपरकेस वर्णमाला के उपयोग से कस्टम बेस में रूपांतरण 6 लंबाई की स्ट्रिंग में होता है, जिसे बाद में अक्षरों के जोड़े में विभाजित किया जाता है।

¹

प्रिंट करें -।

⊟η

पत्रों की अंतिम जोड़ी को प्रिंट करें।

Ｍ⁹←

नंबर प्लेट की शुरुआत में ले जाएं।

⊟η

बाकी वांछित अक्षरों को प्रिंट करें।

— नील
स्रोत
3

एक्सेल, 183 167 155 147 बाइट्स

-16 बाइट्स @ @ नील को धन्यवाद। (6 का उपयोग करके E3)

-12 बाइट्स @Keeta को धन्यवाद। (के TRUNCबजाय QUOTIENT)

-8 बाइट्स @Jonathan Larouche (के 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))
— Wernisch
स्रोत
करता है MOD(QUOTIENT(A1,1E3),26)काम नहीं? इसके अलावा, क्यों 1E3के लिए 1000नहीं बल्कि 26E3आदि?
— नील
TRUNC को पूरी तरह हटाकर और विभाजन को MOD ​​के अंदर ले जाकर और भी अधिक सहेजें। = CHAR (65 + ए 1 / 17576E3) और CHAR (65 + एमओडी (ए 1 / 676E3,26)) और "-" और पाठ (एमओडी (A1,1E3), "000") और "-" और CHAR (65 + एमओडी (A1 / 26E3,26)) और CHAR (65 + MOD (A1 / 1E3,26)) इसे 127 बाइट्स तक नीचे लाता है।
— कीता
मेरा मतलब था QUOTIENT हटाना। मूल रूप से मैं अल्पविराम के बजाय / के साथ trunc को बदलने के लिए सुझाव दे रहा था।
— कीता
@Keeta, आपका 127 बाइट समाधान कुछ मूल्यों के लिए विफल रहता है: जैसे 456 975 996->[Z-996-ZZ
— Wernisch
@ कीटा, लगता है जैसे CHAR(65+)चुपचाप दशमलव को काटती है %.9999997614649। उससे भी बड़ा गोल है। तुलना CHAR(65+24.9999997614649)और CHAR(65+24.999999761465)।
— वेर्निस्क
2

जाप , 21 बाइट्स

अश्लील धीमी गति से! गंभीरता से, इसे चलाने की कोशिश भी मत करो!

केविन के लिए टोपी का टिप मुझे यह एहसास दिलाता है कि कल रात यह काम करने के लिए लड़ते समय मैं कहां गलत था।

;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)
— झबरा
स्रोत
2

फोर्थ (gforth) , 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
— reffu
स्रोत
2

क्यू , 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
— घसीट
स्रोत
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 इनपुट के एक चार ( फ़ंक्शन Aसे 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)]')
— Hoki
स्रोत
1

सी (जीसीसी) , 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);}

इसे ऑनलाइन आज़माएं!

Cellingcat के समाधान से -7 बाइट्स , अतिरिक्त -23 से प्रेरित

-1 ceilingcat से बाइट समाधान बदलकर char[]करने के लिए एक wchar_t[]परोक्ष करने के लिए डालीint[]

0-आधारित अनुक्रमण का उपयोग करता है।

स्पष्टीकरण / 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
स्रोत
@ceilingcat धन्यवाद! उस विचार का उपयोग करके मैंने मैक्रो से मापदंडों aऔर bमापदंडों को हटा दिया और 106 बाइट्स
— pizzapants184
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.