Die Herausforderung

Geben Sie zwei Ganzzahlen als Eingabe ( xund y) ein und geben Sie sie xals Zeichenfolge mit so vielen führenden Nullen aus, dass die yZeichen ohne Vorzeichen lang sind.

Regeln

• Wenn xmehr als yZiffern vorhanden sind, wird die Ausgabe xohne Änderung als Zeichenfolge ausgeführt.

• Die Ausgabe als Ganzzahl wird nicht akzeptiert, auch wenn keine führenden Nullen vorhanden sind.

• Wenn xnegativ, behalten Sie den Ist- Zustand bei -und arbeiten Sie mit dem Absolutwert.

• Negativ ysollte als 0 behandelt werden, was bedeutet, dass Sie so ausgeben, xwie es ist (aber als Zeichenfolge)

Beispiele:

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"

Kürzester Code in Bytes gewinnt, Standardlücken gelten.

Japt , 13 8 Bytes

Nimmt die erste Eingabe ( x) als Zeichenfolge.

®©ùTV}'-

Versuch es

Dank ETHproductions konnten satte 5 Bytes eingespart werden.

Erläuterung

Implizite Eingabe von Zeichenfolge U=xund Ganzzahl V=y.

® }'-Teilt sich Uin ein Array auf dem Minus-Symbol, ordnet es darüber zu und fügt es einer Zeichenfolge mit einem Minus-Symbol wieder hinzu.

©&&Ist logisch AND ( ), wenn das aktuelle Element wahr ist (eine nicht leere Zeichenfolge), füllen Sie left ( ù) mit 0 ( T) auf V.

Pyth , 12 Bytes

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

Probieren Sie es hier aus!

Python 2 , 29 Bytes

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

Probieren Sie es online!

str.zfillKommt einfach so nah.

05AB1E , 11 10 Bytes

Eingabe erfolgt als amount_of_digits, number

ÎIÄg-×ì'-†

Probieren Sie es online!

Erläuterung

Î            # 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

Python, 29 Bytes

Eingabe übernehmen als f(x,y). Verwenden des Python- %Operators

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

Probieren Sie es online!

C #, 56 Bytes

Probieren Sie es online!

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

Java (OpenJDK 8) , 47 Byte

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

Probieren Sie es online!

Anfangs dachte ich, einfach, maximal 30 Zeichen (was ziemlich kurz ist, wenn man Strings in Java manipuliert). Dann passierten die Ausnahmen.

JavaScript (ES6), 42

Rekursiv, Parameter in umgekehrter Reihenfolge, zuerst y, dann x. Und Currys

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

Prüfung

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

Python 3.6 , 28 37 Bytes

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

Probieren Sie es online! (Testfall aus der Antwort von Colera Su)

Nutzen Sie die neue Methode zum Formatieren von Zeichenfolgen in Python 3.6

+9 Bytes zu handhaben y<0

Bash, 27 , 25 Bytes

-2 Bytes dank Bruce Forte

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

versuche es online

Schale , 12 Bytes

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

Probieren Sie es online!

Erläuterung

Ö±Ω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.

R, 56 48 Bytes

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

Probieren Sie es online!

-8 Bytes dank Djhurio

Erläuterung

• sprintf("%0zd",x)Gibt xals Zeichenfolge zurück, die mit Nullen aufgefüllt ist, um eine Länge zu habenz
• paste0("%0",y+(x<0),"d")Konstruiert die Zeichenfolge "%0zd", wobei zist y, plus 1, wenn xkleiner als Null ist
• Wenn zkleiner als die Anzahl der Ziffern in ist x, xwird der Ausdruck unverändert als Zeichenfolge ausgegeben

Alice , 23 Bytes

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

Probieren Sie es online!

Die Eingabe sollte mit der Nummer in der ersten Zeile und der Breite in der zweiten Zeile durch einen Zeilenvorschub getrennt sein.

Erläuterung

/...
\...@/

Dies ist der übliche Rahmen für lineare Programme im Ordinalmodus. Der einzige Haken in diesem Fall ist dieses Bit:

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

Dies bewirkt, dass die IP vertikal in den Kardinalmodus wechselt und nur den Befehl ausführt & Kardinalmodus bevor sie wieder in den Ordinalmodus wechselt.

Das Entfalten des Zickzack-Kontrollflusses ergibt dann:

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.

Hier sind zwei Alternativen, ebenfalls bei 23 Bytes, die Cardinal H( abs ) verwenden, um das loszuwerden -:

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

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

Im Prinzip sind diese Befehle kürzer, aber &sie passen nicht in eine Position, in der sich eine 1-Zeichen-Zeichenfolge auf dem Stapel befindet. Wir müssen sie daher mit einem überspringen #.

C 33 Bytes

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

Probieren Sie es online!

Kohle , 16 13 Bytes

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

Probieren Sie es online!

Dies ist der kürzeste Zeitraum, in dem ich Charcoal verwenden kann, ohne führende oder nachfolgende Leerzeichen zu drucken. Zumindest fange ich jetzt an zu verstehen, wie man die ModuloFunktion zum Formatieren von Strings verwendet.

Der deverbosed Code lautet wie folgt:

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 Bytes gespart dank Neil!

Retina , 39 Bytes

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

Probieren Sie es online!

Die Eingabe sollte durch Kommas getrennt sein, wobei die Nummer an erster Stelle und die Breite an zweiter Stelle stehen.

PHP, 45 Bytes

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

oder

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

Laufen Sie mit -nroder probieren Sie sie online aus .

Mathematica, 118 Bytes

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

Probieren Sie es online!

Mathematica, 63 62 Bytes

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

Probieren Sie es online!

Excel, 29 Bytes

Verwenden von Excel TEXT Funktionalität ("Konvertiert einen Wert in Text in einem bestimmten Zahlenformat").

xin A1, yin B1

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

Oktave , 44 Bytes

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

Probieren Sie es online!

Haskell , 54 Bytes

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

Probieren Sie es online!

Ruby , 31 28 Bytes

Vielen Dank an Carl, dass er 3 Bytes durch Interpolation eingespart hat.

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

Probieren Sie es online!

Japt , 14 12 Bytes

2 Bytes gespart dank @ETHproductions

s r"%d+"_ù0V

Probieren Sie es online aus

PowerShell , 25 bis 40 Byte

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

Probieren Sie es online!

Erläuterung

Dies ruft .ToString()die Zahl mit einer generierten Formatzeichenfolge auf, multipliziert sie jedoch mit -1, 0 oder 1, je nachdem, ob $b( y) negativ, 0 oder positiv ist. Dies dient dazu, negative yWerte zu verarbeiten , die Formatstrings nicht von sich aus haben.

Dies scheint zu erfordern, dass negative Zahlen in eine Unteranweisung eingeschlossen werden, ()damit dies funktioniert. Dies ist nur eine Eigenheit des Aufrufs, wenn Literale verwendet werden. Wenn Variablen vom Typ Integer übergeben werden, wird dies nicht benötigt.

C # 6.0, 35 Bytes

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

Alternative Lösung (51 Bytes)

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

Sauber , 90 86 83 Bytes

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

Probieren Sie es online!

C (gcc) , 45 Bytes

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

Probieren Sie es online!

Erläuterung

printf formatiert drei Argumente:

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

%sformatiert die Zeichenfolge "-"+(x>=0). "-"ist eigentlich nur eine adresse, sowas 41961441. Im Gedächtnis sieht das ungefähr so ​​aus:

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

Bei der Formatierung in eine Zeichenfolge nimmt C die Adresse (z. B. 41961441) und erfasst so lange Zeichen, bis ein Nullbyte (0x00) erreicht wird. Wenn x kleiner als Null ist, hat der Wert "-"+(x>=0)den der ursprünglichen Adresse (41961441). Andernfalls x>=0ist 1, so dass der Ausdruck wird "-"+1, der auf das nachfolgende Null-Byte verweist"-" , das nichts ausgibt.

%0*iGibt eine Ganzzahl aus, die mit einer angegebenen Anzahl von 0s aufgefüllt ist . ybezeichnet diese Nummer. Wir füllen abs(x)auf, um das Negative in einigen Argumenten zu vermeiden.

Perl, 25 + -nFlag = 26 Bytes

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

Probieren Sie es online!

Perl 5, 22 + 1 (- n) = 23 Bytes

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

Probieren Sie es online aus