प्रमुख शून्य चुनौती देते हैं

Question

चुनौती

इनपुट ( xऔर y) के रूप में दो पूर्णांकों को देखते हुए , xएक स्ट्रिंग के रूप में आउटपुट के रूप में कई प्रमुख शून्य इसके लिए आवश्यक हैं कि यह yबिना संकेत के वर्ण लंबा हो।

नियम

• यदि अंकों xसे अधिक है y, तो xसंशोधन के बिना स्ट्रिंग के रूप में आउटपुट ।

• पूर्णांक के रूप में आउटपुट स्वीकार नहीं किया जाता है, भले ही कोई अग्रणी शून्य न हो।

• जब xनकारात्मक है, रखना -है के रूप में और निरपेक्ष मूल्य पर कार्य करते हैं।

• नकारात्मक yको 0 के रूप में माना जाना चाहिए, जिसका अर्थ है कि आप आउटपुट हैं x(लेकिन स्ट्रिंग के रूप में)

उदाहरण:

IN: (1,1)   OUT: "1"
IN: (1,2)   OUT: "01"
IN: (10,1)  OUT: "10"
IN: (-7,3)  OUT: "-007"
IN: (-1,1)  OUT: "-1"
IN: (10,-1) OUT: "10"
IN: (0,0)   OUT: "0"
IN: (0,1)   OUT: "0"
IN: (0,4)   OUT: "0000"

बाइट्स जीत में सबसे छोटा कोड, मानक खामियां लागू होती हैं।

Comments

सैंडबॉक्स: codegolf.meta.stackexchange.com/a/14264/69737

— ब्रायन एच।

क्या मैं x को स्ट्रिंग के रूप में ले सकता हूं?

— लाईफ़डेवेन

क्या (-1,1)देता है?

— Adám

@ Adám ने इसे उदाहरणों में जोड़ा।

— ब्रायन एच।

क्या +सकारात्मक संख्याओं के लिए एक अग्रणी संकेत स्वीकार्य है?

— टॉम कारपेंटर

Answer 1

जाप , 13 8 बाइट्स

xएक स्ट्रिंग के रूप में पहला इनपुट ( ) लेता है ।

®©ùTV}'-

कोशिश करो

ETHproductions के लिए एक बड़े पैमाने पर 5 बाइट्स को बचाया।

---

व्याख्या

स्ट्रिंग U=xऔर पूर्णांक का निहित इनपुट V=y।

® }'-Uमाइनस सिंबल पर एक ऐरे में विभाजित होता है, उस पर मैप करता है और इसे माइनस सिंबल के साथ स्ट्रिंग में शामिल करता है।

©तार्किक और ( &&) है, इसलिए यदि वर्तमान तत्व सत्य है (एक गैर-रिक्त स्ट्रिंग) तो पैड लेफ्ट ( ù) 0 ( T) लंबाई के साथ V।

Comments

अच्छा है! आप लगभग बस मैप करके थोड़ा सा बचा सकते हैं -: ethproductions.github.io/japt/…

— ETHproductions

@ETHproductions: शानदार कॉल। धन्यवाद। जब तक मैंने ऐसा किया है, तब तक मैं पूरी तरह से भूल गया हूँ कि आप विभाजन कर सकते हैं, नक्शा कर सकते हैं और एक स्ट्रिंग को एक ही विधि से जोड़ सकते हैं!

— झबरा

हां, मुझे लगता है कि कार्यक्षमता को स्थानांतरित किया जाना चाहिए q, जो तब q-_©ùTV1 बाइट को बचाने के लिए होगा :-)

— ETHproductions

@ETHproductions, अगर मैं उस अधिकार को समझ रहा हूं, तो आप सुझाव दे रहे हैं कि यदि किसी फ़ंक्शन को S.q()(हमें देने S.q(s,f)) के दूसरे तर्क के रूप में पारित किया जाता है, तो Sउस पर विभाजित हो जाएगा s, के माध्यम से fऔर फिर से जुड़ जाएगा s? मुझें यह पसंद है! :)

— झबरा

हाँ, क्या मैंने ओलिवर से बात की है और आप ऐसा करने के बारे में नहीं हैं (यदि कोई फ़ंक्शन पारित हो गया है, सामान्य कार्यक्षमता करें, फ़ंक्शन के माध्यम से चलाएं, और पहले परिवर्तन को पूर्ववत करें; N.sऔर S/A.y, N.ìयह पहले से ही करें) तरीकों का एक गुच्छा के साथ? किसी के साथ मेरी बातचीत हुई, मुझे अभी याद नहीं है कि अब कौन है: s

— ETHproductions

Answer 2

पायथ , 12 बाइट्स

%"%0*d",+E>0

यहाँ कोशिश करो!

Answer 3

पायथन 2 , 29 बाइट्स

lambda x,y:x.zfill(y+(x<'.'))

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

बस str.zfillइतना करीब आता है।

Answer 4

05AB1E , 11 10 बाइट्स

इनपुट के रूप में दिया गया amount_of_digits, number

ÎIÄg-×ì'-†

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

व्याख्या

Î            # push 0 and first input
 IÄ          # push the absolute value of the second input
   g         # length
    -        # subtract, (input1-len(abs(input2))
     ×       # repeat the zero that many times
      ì      # prepend to the second input
       '-†   # move any "-" to the front

Comments

ऐसा लगता है कि यह अब तक का विजयी उत्तर है, यदि कल बेहतर नहीं किया गया तो मैं इसे स्वीकार कर लूंगा।

— ब्रायन एच।

आप बहिष्कृत हो गए हैं :(

— ब्रायन एच।

@BrianH। वास्तव में मेरे पास :)

— एमिग्ना

Answer 5

पायथन, 29 बाइट्स

इनपुट के रूप में लें f(x,y)। पायथन के %ऑपरेटर का उपयोग करना ।

lambda x,y:'%0*d'%(y+(x<0),x)

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

Answer 6

सी #, 56 बाइट्स

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

a=>b=>(a<0?"-":"")+((a<0?-a:a)+"").PadLeft(b<0?0:b,'0')

Answer 7

जावा (ओपनजेडके 8) , 47 बाइट्स

x->y->"".format("%0"+((y<1?1:y)-(x>>31))+"d",x)

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

पहले मैंने सोचा, आसान, 30 चार्ट्स अधिकतम (जो जावा में स्ट्रिंग्स में हेरफेर करते समय काफी कम है)। फिर अपवाद हुए।

Answer 8

जावास्क्रिप्ट (ईएस 6), 42

पुनरावर्ती, रिवर्स ऑर्डर में पैरामीटर, पहले y फिर x। और करी

y=>r=x=>x<0?'-'+r(-x):`${x}`.padStart(y,0)

परीक्षा

var F=
y=>r=x=>x<0?'-'+r(-x):`${x}`.padStart(y,0)

;`IN: (1,1)   OUT: "1"
IN: (1,2)   OUT: "01"
IN: (10,1)  OUT: "10"
IN: (-7,3)  OUT: "-007"
IN: (-1,1)  OUT: "-1"
IN: (10,-1) OUT: "10"
IN: (0,0)   OUT: "0"
IN: (0,1)   OUT: "0"
IN: (0,4)   OUT: "0000"`
.split(`\n`).map(r => r.match(/[-\d]+/g))
.forEach(([x,y,k])=>{
  o = F(y)(x)
  ok = o == k
  console.log(ok?'OK':'KO',x,y,'->', o)
})

Comments

प्रभावशाली होने के दौरान, मुझे लगता है कि यह उत्तर फ़ंक्शन को परिभाषित करने के f(y)(x)बजाय नियमों को थोड़ा छोटा करता है f(x,y)।

— स्टाइललेट

"करी" नियमों पर पढ़ते हुए, मैं यह जोड़ना चाहता था कि मेरी आपत्ति उलटे हुए पैरामेट्स के साथ अधिक थी और न कि करीने से।

— स्टाइललैटन

@styletron मापदंडों का क्रम चुनौती में निर्दिष्ट नहीं है। इसलिए मैं इसका फायदा उठा सकता हूं

— edc65

डांग, y=>r=x=>x<0?'-'+r(-x):(x+='')[y-1]?x:r(0+x)इतना करीब आता है ...

— ETHproductions

मेरे पास इनपुट आदेश को उलटने वाले लोगों के साथ कोई समस्या नहीं है।

— ब्रायन एच।

Answer 9

पायथन 3.6 , 28 37 बाइट्स

lambda x,y:f'{x:0{(y,0)[y<0]+(x<0)}}'

इसे ऑनलाइन आज़माएं! (कोलेरा सु के जवाब से टेस्ट केस)

अजगर 3.6 में तार को प्रारूपित करने के नए तरीके का लाभ उठा रहा है

+9 बाइट्स को संभालने के लिए y<0

Comments

yनकारात्मक होने पर ऐसा लगता है: tio.run/##K6gsycjPM/…

— Shaggy

वास्तव में। तो मैं 37 बाइट्स के साथ हूं।

— १२:२२ में लेसकुरेल

Answer 10

बैश, 27 , 25 बाइट्स

-2 बाइट्स थैंक्स टू ब्रूस फोर्ट

printf %0$[$2+($1<0)]d $1

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

Comments

पेडिंग की लंबाई को कम करके आप दो बाइट्स बचा सकते हैं । इसके अलावा एक और दिलचस्प एक (28 बाइट्स) printf %\ 0$[1+$1]d $2|xargs:।

— ।

शायद आपका मतलब है printf %\ 0$[1+$2]d $1|xargs, मुझे हस्ताक्षरित संख्याओं के लिए इस प्रारूप को याद नहीं था कि अग्रणी स्थान को हटाने के लिए xargs की चाल भी है

— Nahuel Fouilleul

Answer 11

भूसी , 12 बाइट्स

Ö±Ωo≥⁰#±:'0s

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

व्याख्या

Ö±Ωo≥⁰#±:'0s  Inputs are y=4 and x=-20
           s  Convert x to string: "-20"
        :'0   Prepend '0'
  Ω           until
      #±      the number of digits
   o≥⁰        is at least y: "00-20"
Ö±            Sort by is-digit: "-0020"
              Print implicitly.

Answer 12

आर, 56 48 बाइट्स

function(x,y)sprintf(paste0("%0",y+(x<0),"d"),x)

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

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

व्याख्या

• sprintf("%0zd",x)xलंबाई के होने के लिए शून्य के साथ एक गद्देदार के रूप में रिटर्नz
• paste0("%0",y+(x<0),"d")स्ट्रिंग का निर्माण करता है "%0zd", जहां zहै y, प्लस 1 यदि xशून्य से कम है
• यदि zअंकों की संख्या से कम है x, xतो एक स्ट्रिंग के रूप में मुद्रित किया जाता है

Comments

48 बाइट्सfunction(x,y)sprintf(paste0("%0",y+(x<0),"d"),x)

— djhurio 14

@djhurio शानदार! मुझे लगता है कि मेरे द्वारा संपादित किए जाने के बजाय एक और जवाब दिया जाएगा, आप क्या कहते हैं?

— duckmayr

आप इसे एक संपादन के रूप में बना सकते हैं। यह समाधान इतना अलग नहीं है, बस अलग-अलग फ़ंक्शन का उपयोग कर रहा है।

— djhurio

Answer 13

ऐलिस , 23 बाइट्स

/oRe./'+Ao
\I*tI&0-R$@/

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

पहली पंक्ति में संख्या और दूसरी पर चौड़ाई के साथ इनपुट को लाइनफीड-अलग किया जाना चाहिए।

व्याख्या

/...
\...@/

यह ऑर्डिनल मोड में रैखिक कार्यक्रमों के लिए सामान्य रूपरेखा है। इस मामले में एकमात्र पकड़ यह है:

.../...
...&...

यह IP को कार्डिनल मोड में लंबवत रूप से दर्ज करने का कारण बनता है और &साधारण मोड में फिर से शुरू होने से पहले कार्डिनल मोड में निष्पादित करता है।

ज़िगज़ैग नियंत्रण प्रवाह को अनफॉलो करना तब देता है:

IRt.&'-A$o*eI/&/0+Ro@

I    Read the first line of input (the value) as a string.
R    Reverse the string.
t.   Split off the last character and duplicate it.
&    Fold the next command over this string. This doesn't really do anything,
     because the string contains only one character (so folding the next
     command is identical to executing it normally).
'-   Push "-".
A    Set intersection. Gives "-" for negative inputs and "" otherwise.
$o   If it's "-", print it, otherwise it must have been a digit which we
     leave on the stack.
*    Join the digit back onto the number. If the number was negative, this
     joins the (absolute value of the) number to an implicit empty string,
     doing nothing.
e    Push an empty string.
I    Read the width W.
/&/  Iterate the next command W times.
0    Append a zero. So we get a string of W zeros on top of the absolute
     value of the input number.
+    Superimpose. This takes the character-wise maximum of both strings
     and appends extraneous characters from the longer string. Since the
     string of zeros can never be larger than the digits in the input,
     the input itself will be uneffected, but extraneous zeros are appended,
     padding the string to the required length.
R    Reverse the result.
o    Print it.
@    Terminate the program.

यहाँ 23 बाइट्स पर दो विकल्प दिए गए हैं, जो छुटकारा पाने के लिए कार्डिनल H( पेट ) का उपयोग करते हैं -:

/R.I&0-RoH
\Ie#\'+Ao\@/

/R.H#/.+Xo
\Ie\I&0QRo@/

सिद्धांत रूप में, ये एक कमांड शार्ट होते हैं, लेकिन &ऐसी स्थिति में फिट नहीं होते हैं जहाँ स्टैक पर 1-कैरेक्टर स्ट्रिंग हो, इसलिए हमें इसे छोड़ना होगा #।

Answer 14

सी, 33 बाइट्स

f(x,y){printf("%0*d",y+(x<0),x);}

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

Answer 15

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

‹Ｎ⁰﹪⁺⁺%0ηd↔Ｉθ

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

यह सबसे छोटा है जिसे मैं चारकोल का उपयोग कर सकता था, जो प्रमुख व्हाट्सएप को प्रिंट या ट्रेस किए बिना किया जा सकता था। कम से कम मैं अब यह समझने लगा हूं कि Moduloफ़ंक्शन का उपयोग स्ट्रिंग्स को प्रारूपित करने के लिए कैसे करें ।

निम्न कोड निम्नानुसार है:

Print(Less(InputNumber(),0));    # Prints a - if the first input is less than 0
Print(Modulo(Add(Add("%0",h),"d"),Abs(Cast(q))));   # q: first input;  h: second input

• 3 बाइट्स ने नील को दिया धन्यवाद!

Comments

-चारकोल में प्रिंट करना या कुछ भी करना वास्तव में आसान नहीं है: -0 प्रिंट करते हुए 1 प्रिंट करना और कुछ नहीं प्रिंट करना। तो, टर्नरी शानदार है, जिससे 3 बाइट्स बचती हैं।

— नील

यदि आप के InputNumber()साथ स्वैप करते हैं Cast(q), तो मुझे लगता है कि आप किसी अन्य बाइट को बचाने के लिए एक स्ट्रिंग तुलना में स्विच कर सकते हैं।

— नील

@ नील मुझे पता था कि मैं सरल कर सकता हूँ Ternary!

— चार्ली

Answer 16

रेटिना , 39 बाइट्स

\d+$
$*0
((\d)*),(?<-2>-0+|0)*(0*)
$3$1

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

इनपुट को पहले नंबर और चौड़ाई दूसरी के साथ अल्पविराम से अलग किया जाना चाहिए।

Answer 17

PHP, 45 बाइट्स

printf("%0".($argv[2]+(0>$n=$argv[1])).d,$n);

या

[,$n,$e]=$argv;printf("%0".($e+(0>$n)).d,$n);       # requires PHP 7.1 or later

ऑनलाइन चलाएं -nrया उन्हें आज़माएं ।

Comments

उस लिंक में कोड निष्पादित करते समय एक त्रुटि हो रही है।

— झबरा

@ शैगी दूसरे संस्करण के लिए पीएचपी 7.1 की आवश्यकता है

— टाइटस

मैं इस बारे में और आगे बढ़ता गया, और मैं इस जवाब पर पहुंचा। मेरा मानना ​​है कि यह

— इस्माइल मिगुएल

Answer 18

गणितज्ञ, ११hem बाइट्स

(j=ToString;If[#2<=0,j@#,If[(z=IntegerLength@#)>=#2,t=z,t=#2];s=j/@PadLeft[IntegerDigits@#,t];If[#>=0,""<>s,"-"<>s]])&

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

Answer 19

गणितज्ञ, 63 62 बाइट्स

If[#<0,"-",""]<>IntegerString[#,10,Max[#2,IntegerLength@#,1]]&

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

Comments

PPCG में आपका स्वागत है! मुझे लगता है कि यह वह नहीं है जो आप चाहते हैं। आप शायद IntegerLengthइसके बजाय मतलब था IntegerDigits। आप हालांकि के IntegerLength@#बजाय का उपयोग करके एक बाइट बचा सकते हैं IntegerLength[#]।

— मार्टिन एंडर

धन्यवाद! मैं कोड को दूसरे कंप्यूटर से हाथ से कॉपी कर रहा था जहाँ मैं इसका परीक्षण कर रहा था और मैंने वास्तव में IntegerDigits को IntegerLength के लिए गलत समझा। यह अब काम करना चाहिए। मैंने चुनौती विवरण (+1) में सभी परीक्षण मामलों के साथ एक टीआईओ लिंक भी जोड़ा है जो यह दर्शाता है कि यह उम्मीद के मुताबिक काम करता है। अतिरिक्त बाइट को बचाने के सुझाव के लिए भी धन्यवाद! मुझे नहीं पता कि मैं इससे पहले कैसे चूक गया। :)

— MatjazGo

Answer 20

एक्सेल, 29 बाइट्स

एक्सेल की TEXTकार्यक्षमता का उपयोग करना ("एक विशिष्ट संख्या प्रारूप में पाठ के लिए एक मूल्य देता है")।

xए 1 में, yबी 1 में

=TEXT(A1,REPT("0",MAX(1,B1)))

Comments

)))Google शीट्स

— टेलर स्कॉट

Answer 21

ऑक्टेव , 44 बाइट्स

@(x,y)fprintf(['%0',num2str(y+(x<0)),'d'],x)

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

Comments

31 बाइट्स के लिए

— टॉम कारपेंटर

यदि सकारात्मक संख्याओं के लिए अग्रणी + संकेतों की अनुमति है (ठीक है, तो ऑप से सुनने के लिए इंतजार कर रहा है), यह 28 के लिए काम करता है ।

— टॉम कारपेंटर

Answer 22

हास्केल , 54 बाइट्स

x#y|s<-show$abs$x=['-'|x<0]++('0'<$[length s+1..y])++s

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

Answer 23

रूबी , 31 28 बाइट्स

प्रक्षेप के उपयोग से 3 बाइट बचाने के लिए धन्यवाद कार्ल ।

->x,y{"%0#{y+(x<0?1:0)}d"%x}

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

Comments

28: -> x, y {"% 0 # {y + (x <0; 1: 0)} d"% x}

— कार्ल

Answer 24

जाप , 14 12 बाइट्स

सहेजे गए 2 बाइट्स @ETHproductions के लिए धन्यवाद

s r"%d+"_ù0V

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

Comments

शून्य से प्रवेश करने और अंकों के साथ खिलवाड़ करने के लिए यह थोड़ा सस्ता है: इसे ऑनलाइन टेस्ट करें

— ETHproductions

@ETHproductions: या 10 बाइट्स केx लिए एक स्ट्रिंग के रूप में लें ।

— झबरा

@ETHproductions धन्यवाद साथियों। अपने डेस्क पर वापस आने पर मैं इसे अपडेट करूंगा।

— ओलिवर

@ शैगी लगता है जैसे आपने अपना जवाब पोस्ट किया है, इसलिए मैं ETHproduction की चाल का उपयोग करूँगा। हालांकि धन्यवाद।

— ओलिवर

ओलिवर, कि 10-बायटर सिर्फ @ ETHproduction का 12-बाइट समाधान है, जिसे जाप 2.0a0 में अपग्रेड किया Uगया है, एक स्ट्रिंग के रूप में जो हमें पहले 2 वर्णों को बंद करने की अनुमति देता है।

— झबरा

Answer 25

पॉवरशेल , 25 40 बाइट्स

param($a,$b)$a|% *g $("D$b"*($b|% *o 0))

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

व्याख्या

यह .ToString()एक उत्पन्न प्रारूप स्ट्रिंग के साथ संख्या पर कॉल करता है, लेकिन इसे -1, 0, या 1 के आधार पर गुणा करता है कि क्या $b( y) नकारात्मक, 0 या सकारात्मक है; यह उन नकारात्मक yमानों को संभालने के लिए है, जो स्वरूपण स्वयं से नहीं करते हैं।

ऐसा लगता है कि ()यह काम करने के लिए एक प्रतिस्थापन में नकारात्मक संख्याओं को लपेटने की आवश्यकता है, जो कि शाब्दिक रूप से उपयोग करते समय आह्वान का एक क्विक है; यदि प्रकार पूर्णांक के चर पारित किए जाते हैं, तो उसे इसकी आवश्यकता नहीं होगी।

Comments

ऐसा लगता है कि yनकारात्मक होने पर ये दोनों विफल हो जाते हैं ।

— झबरा

@ सुग्गी उघ अच्छा कैच। दूसरे समाधान को पूरी तरह से हटा दिया और पहले को तय किया, धन्यवाद!

— रिश्वतखोर

आउच, 15 बाइट्स! माफ़ कीजिये!

— झबरा

@ शैगी हे, इन दिनों में से एक मैं वास्तव में PowerShell- आधारित गोल्फिंग भाषा लिखूंगा जिसके बारे में मैं सोच रहा था। इसने वास्तव में मुझे थोड़ा और शोध करने और इसे शुरू करने के करीब लाने के लिए प्रेरित किया, इसलिए इसके लिए धन्यवाद;)

— ब्रायंटिस्ट

Answer 26

सी # 6.0, 35 बाइट्स

(x,y)=>(x.ToString($"D{y<0?0:y}"));

वैकल्पिक समाधान (51 बाइट्स)

(x,y)=>(x.ToString(string.Format("D{0}",y<0?0:y)));

Answer 27

क्लीन , 90 86 83 बाइट्स

import StdEnv
@x y=if(y<0)"-"""+++{if(c>'-')c'0'\\c<-rjustify x[k\\k<-:toString y]}

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

Answer 28

सी (जीसीसी) , 45 बाइट्स

f(x,y){printf("%s%0*i","-"+(x>=0),y,abs(x));}

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

व्याख्या

printf तीन तर्क प्रारूप:

%s      ->    "-"+(x>=0)
%0*i    ->    y
        ->    abs(x)

%sस्ट्रिंग को प्रारूपित करता है "-"+(x>=0)। "-"वास्तव में सिर्फ एक पता है, कुछ पसंद है 41961441। स्मृति में, यह कुछ इस तरह दिखता है:

MEMORY ADDRESS | 41961441  41961442 ...
VALUE          | 45 ('-')  0 (0x00) ...

जब एक स्ट्रिंग में स्वरूपित किया जाता है, C पता (41961441 कहता है) लेता है और एक अशक्त बाइट (0x00) मिलने तक वर्ण प्राप्त करता रहता है। जब x शून्य से कम होता है, तो मान "-"+(x>=0)में मूल पता (41961441) होता है। अन्यथा, x>=01 है, इसलिए अभिव्यक्ति बन जाती है "-"+1, जो बाद में शून्य बाइट को इंगित करता है "-", जो कुछ भी नहीं प्रिंट करता है।

%0*iएक पूर्णांक मुद्रित करता है जिसमें निर्दिष्ट संख्या होती है 0। yइस संख्या को दर्शाता है। हम abs(x)कुछ तर्कों में नकारात्मक से बचने के लिए पैड करते हैं।

Answer 29

पर्ल, 25 + -nध्वज = 26 बाइट्स

printf"%0*d",<>+($_<0),$_

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

Answer 30

पर्ल 5, 22 + 1 (- n) = 23 बाइट्स

printf"%0*d",<>+/-/,$_

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

Comments

लूप्स असीम पर10,-1

— ज़ैद

नियत+5 bytes

— नहुएल फौलीउल

एक और समाधान मिला-5 bytes

— नाहुएल फौइलुल

मिठाई। मैं एक के रूप में अच्छी तरह से काम कर रहा हूँ ... देखते रहें

— Zaid

मैंने इसे 26 बाइट्स

— Zaid