Wyzwanie

Biorąc pod uwagę dwie liczby całkowite jako dane wejściowe ( xi y), dane wyjściowe xjako ciąg znaków z tyloma zerami wiodącymi, że jest to ydługość znaków bez znaku.

Zasady

• Jeśli xma więcej niż ycyfry, wyprowadzane jest xjako ciąg bez modyfikacji.

• Wyjście jako liczba całkowita nie jest akceptowane, nawet jeśli nie ma zer wiodących.

• Kiedy wartość xjest ujemna, zachowaj „tak -jak jest” i operuj na wartości bezwzględnej.

• Negatyw ypowinien być traktowany jako 0, co oznacza, że ​​wyprowadzasz dane xtakie, jakie są (ale jako ciąg)

Przykłady:

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"

Najkrótszy kod w bajtach wygrywa, obowiązują standardowe luki.

Japt , 13 8 bajtów

Pobiera pierwsze wejście ( x) jako ciąg.

®©ùTV}'-

Spróbuj

Zaoszczędź 5 bajtów dzięki produktom ETH.

Wyjaśnienie

Domniemane wprowadzanie ciągu U=xi liczby całkowitej V=y.

® }'-dzieli Usię na tablicę na symbolu minus, mapuje nad nią i ponownie łączy ją z ciągiem z symbolem minus.

©jest logiczne AND ( &&), więc jeśli bieżący element jest prawdziwy (niepuste ciąg), następnie wstaw lewą ( ù) wartość 0 ( T) do długości V.

Pyth , 12 bajtów

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

Wypróbuj tutaj!

Python 2 , 29 bajtów

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

Wypróbuj online!

Po prostu str.zfilljest tak blisko.

05AB1E , 11 10 bajtów

Dane wejściowe podane jako amount_of_digits, number

ÎIÄg-×ì'-†

Wypróbuj online!

Wyjaśnienie

Î            # 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 bajtów

Weź dane jako f(x,y). Korzystanie z %operatora Pythona .

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

Wypróbuj online!

C #, 56 bajtów

Wypróbuj online!

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

Java (OpenJDK 8) , 47 bajtów

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

Wypróbuj online!

Na początku pomyślałem, łatwe, maksymalnie 30 znaków (co jest dość krótkie, gdy manipuluję łańcuchami w Javie). Potem zdarzyły się wyjątki.

JavaScript (ES6), 42

Rekurencyjne, parametry w odwrotnej kolejności, najpierw y, a następnie x. I curry

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

Test

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 bajtów

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

Wypróbuj online! (Przypadek testowy z odpowiedzi Colera Su)

Wykorzystanie nowego sposobu formatowania napisów w Pythonie 3.6

+9 bajtów do obsłużenia y<0

bash, 27 , 25 bajtów

-2 bajty dzięki Bruce Forte

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

spróbuj online

Łuska , 12 bajtów

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

Wypróbuj online!

Wyjaśnienie

Ö±Ω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 bajtów

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

Wypróbuj online!

-8 bajtów dzięki djhurio

Wyjaśnienie

• sprintf("%0zd",x)zwraca xjako ciąg wypełniony zerami o długościz
• paste0("%0",y+(x<0),"d")konstruuje ciąg "%0zd", gdzie zjest y, plus 1, jeśli xjest mniejszy od zera
• Jeśli zjest mniejsze niż liczba cyfr w x, xjest drukowane jako ciąg znaków, jak jest

Alice , 23 bajty

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

Wypróbuj online!

Dane wejściowe należy oddzielić od wiersza z liczbą w pierwszym wierszu i szerokością w drugim.

Wyjaśnienie

/...
\...@/

Jest to zwykła struktura programów liniowych w trybie porządkowym. Jedynym haczykiem w tym przypadku jest ten bit:

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

Powoduje to, że IP przechodzi w tryb kardynalny pionowo i wykonuje tylko &tryb kardynalny przed wznowieniem w trybie porządkowym.

Rozłożenie zygzakowatego przepływu sterowania daje następnie:

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.

Oto dwie alternatywy, również w 23 bajtach, które używają Cardinal H( abs ), aby pozbyć się -:

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

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

Zasadniczo są to polecenia krótsze, ale &nie pasują do pozycji, w której na stosie znajduje się łańcuch 1-znakowy, więc musimy pominąć go za pomocą #.

C, 33 bajty

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

Wypróbuj online!

Węgiel drzewny , 16 13 bajtów

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

Wypróbuj online!

Jest to najkrótszy czas, jaki mogę uzyskać przy użyciu węgla drzewnego bez drukowania wiodących lub końcowych białych znaków. Przynajmniej zaczynam rozumieć, jak używać Modulofunkcji do formatowania ciągów.

Odebrany kod wygląda następująco:

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 bajty zapisane dzięki Neilowi!

Siatkówka , 39 bajtów

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

Wypróbuj online!

Dane wejściowe powinny być oddzielone przecinkami cyfrą jako pierwszą, a szerokość drugą.

PHP, 45 bajtów

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

lub

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

Uruchom je -nrlub wypróbuj online .

Mathematica, 118 bajtów

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

Wypróbuj online!

Mathematica, 63 62 bajty

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

Wypróbuj online!

Excel, 29 bajtów

Korzystanie z TEXTfunkcji programu Excel („Konwertuje wartość na tekst w określonym formacie liczbowym”).

xw A1, yw B1

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

Oktawa , 44 bajty

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

Wypróbuj online!

Haskell , 54 bajty

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

Wypróbuj online!

Rubin , 31 28 bajtów

Dzięki Carl za zapisanie 3 bajtów przy użyciu interpolacji.

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

Wypróbuj online!

Japt , 14 12 bajtów

Zaoszczędź 2 bajty dzięki @ETHproductions

s r"%d+"_ù0V

Wypróbuj online

PowerShell , 25 40 bajtów

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

Wypróbuj online!

Wyjaśnienie

To wywołuje .ToString()liczbę z wygenerowanym łańcuchem formatu, ale mnoży ją przez -1, 0 lub 1 na podstawie tego, czy $b( y) jest odpowiednio ujemne, 0 lub dodatnie; służy to do obsługi ywartości ujemnych , których ciągi formatujące same w sobie nie są.

Wydaje się, że wymaga to zawijania liczb ujemnych w podstacji (), aby działało, co jest jedynie dziwactwem wywołania przy użyciu literałów; jeśli przekazane zmienne typu liczba całkowita nie będą tego potrzebować.

C # 6.0, 35 bajtów

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

Alternatywne rozwiązanie (51 bajtów)

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

Czysty , 90 86 83 bajtów

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

Wypróbuj online!

C (gcc) , 45 bajtów

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

Wypróbuj online!

Wyjaśnienie

printf formatuje trzy argumenty:

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

%sformatuje ciąg "-"+(x>=0). "-"to tak naprawdę tylko adres, coś w rodzaju 41961441. W pamięci wygląda to mniej więcej tak:

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

Po sformatowaniu w łańcuch C pobiera adres (powiedzmy 41961441) i kontynuuje pozyskiwanie znaków, dopóki nie zostanie spełniony bajt zerowy (0x00). Gdy x jest mniejsze od zera, wartość "-"+(x>=0)ma wartość oryginalnego adresu (41961441). W przeciwnym razie x>=0wynosi 1, więc wyrażenie staje się "-"+1, co wskazuje na pusty bajt po "-", który nic nie wypisuje.

%0*iwypisuje liczbę całkowitą wypełnioną określoną liczbą 0s. yoznacza ten numer. Padamy, abs(x)aby uniknąć negatywnych argumentów.

Perl, 25 + -nflag = 26 bajtów

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

Wypróbuj online!

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

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

Wypróbuj online