O desafio

Dados dois números inteiros como entrada ( xe y), produza xcomo uma string com o número de zeros à esquerda necessário para que sejam ycaracteres longos sem o sinal.

Regras

• Se xtiver mais de ydígitos, produza xcomo string sem modificação.

• A saída como número inteiro não é aceita, mesmo se não houver zeros à esquerda.

• Quando xfor negativo, mantenha -como está e opere no valor absoluto.

• Negativo ydeve ser tratado como 0, o que significa que você produz xcomo está (mas como string)

Exemplos:

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"

O código mais curto em bytes vence, as brechas padrão se aplicam.

Japonês , 13 8 bytes

Toma a primeira entrada ( x) como uma sequência.

®©ùTV}'-

Tente

Economizou 5 bytes em massa graças ao ETHproductions.

Explicação

Entrada implícita de sequência U=xe número inteiro V=y.

® }'-divide Uem uma matriz no símbolo de menos, mapeia sobre ele e junta-o novamente a uma sequência com um símbolo de menos.

©é lógico AND ( &&), portanto, se o elemento atual for verdadeiro (uma seqüência de caracteres não vazia), arraste para a esquerda ( ù) com 0 ( T) no comprimento V.

Pitão , 12 bytes

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

Experimente aqui!

Python 2 , 29 bytes

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

Experimente online!

Apenas str.zfillchega tão perto.

05AB1E , 11 10 bytes

Entrada fornecida como amount_of_digits, number

ÎIÄg-×ì'-†

Experimente online!

Explicação

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

Tome entrada como f(x,y). Usando o %operador do Python .

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

Experimente online!

C #, 56 bytes

Experimente Online!

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

Java (OpenJDK 8) , 47 bytes

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

Experimente online!

No começo eu pensei, fácil, 30 caracteres no máximo (o que é bastante curto ao manipular strings em Java). Então as exceções aconteceram.

JavaScript (ES6), 42

Parâmetros recursivos, em ordem inversa, primeiro y depois x. E currying

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

Teste

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

Experimente online! (Caso de teste da resposta de Colera Su)

Aproveitando a nova maneira de formatar seqüências de caracteres no python 3.6

+9 bytes para manipular y<0

bash, 27 , 25 bytes

-2 bytes graças a Bruce Forte

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

experimente online

Casca , 12 bytes

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

Experimente online!

Explicação

Ö±Ω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 bytes 48

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

Experimente online!

-8 bytes graças a djhurio

Explicação

• sprintf("%0zd",x)retorna xcomo uma string preenchida com zeros para ter comprimentoz
• paste0("%0",y+(x<0),"d")constrói a string "%0zd", onde zestá y, mais 1 se xfor menor que zero
• Se zfor menor que o número de dígitos x, xserá impresso como uma sequência de caracteres.

Alice , 23 bytes

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

Experimente online!

A entrada deve ser separada pela alimentação de linha com o número na primeira linha e a largura na segunda.

Explicação

/...
\...@/

Essa é a estrutura usual para programas lineares no modo Ordinal. O único problema neste caso é este bit:

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

Isso faz com que o IP entre no modo Cardinal verticalmente e execute apenas o &modo Cardinal antes de continuar no modo Ordinal.

O desdobramento do fluxo de controle em zigue-zague fornece:

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.

Aqui estão duas alternativas, também em 23 bytes, que usam Cardinal H( abs ) para se livrar de -:

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

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

Em princípio, esse comando é mais curto, mas &não se encaixa em uma posição em que haja uma cadeia de 1 caractere na pilha; portanto, precisamos ignorá-lo com a #.

C, 33 bytes

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

Experimente online!

Carvão , 16 13 bytes

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

Experimente online!

Este é o mais curto que pude obter usando o carvão vegetal sem imprimir espaços em branco à esquerda ou à direita. Pelo menos agora estou começando a entender como usar a Modulofunção para formatar seqüências de caracteres.

O código de deverbosed é o seguinte:

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 salvos graças ao Neil!

Retina , 39 bytes

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

Experimente online!

A entrada deve ser separada por vírgula com o número primeiro e a largura segundo.

PHP, 45 bytes

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

ou

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

Corra com -nrou experimente-os online .

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

Experimente online!

Mathematica, 63 62 bytes

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

Experimente online!

Excel, 29 bytes

Usando a TEXTfuncionalidade do Excel ("Converte um valor em texto em um formato numérico específico").

xna A1, yna B1

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

Oitava , 44 bytes

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

Experimente online!

Haskell , 54 bytes

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

Experimente online!

Ruby , 31 28 bytes

Obrigado Carl por salvar 3 bytes usando interpolação.

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

Experimente online!

Japonês , 14 12 bytes

Economizou 2 bytes graças a @ETHproductions

s r"%d+"_ù0V

Experimente online

PowerShell , 25 40 bytes

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

Experimente online!

Explicação

Isso chama .ToString()o número com uma sequência de formato gerada, mas o multiplica por -1, 0 ou 1 com base em se $b( y) é negativo, 0 ou positivo, respectivamente; isso é para lidar com yvalores negativos que as seqüências de formato não fazem por si mesmas.

Isso parece exigir a quebra de números negativos em uma subestação ()para que funcione, o que é apenas uma peculiaridade da invocação ao usar literais; se passadas variáveis ​​do tipo número inteiro, não seria necessário.

C # 6.0, 35 bytes

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

Solução alternativa (51 bytes)

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

Limpo , 90 86 83 bytes

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

Experimente online!

C (gcc) , 45 bytes

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

Experimente online!

Explicação

printf formata três argumentos:

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

%sformata a sequência "-"+(x>=0). "-"é realmente apenas um endereço, algo assim 41961441. Na memória, isso se parece com isso:

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

Quando formatado em uma sequência, C pega o endereço (por exemplo, 41961441) e continua adquirindo caracteres até que um byte nulo (0x00) seja encontrado. Quando x é menor que zero, o valor "-"+(x>=0)tem o do endereço original (41961441). Caso contrário, x>=0é 1, então a expressão se torna "-"+1, que aponta o byte nulo depois "-", que não imprime nada.

%0*iimprime um número inteiro preenchido com um número especificado de 0s. yindica esse número. Nós abs(x)evitamos o negativo em alguns argumentos.

Perl, 25 + -nsinalizador = 26 bytes

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

Experimente online!

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

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

Experimente online