O principal desafio dos zeros

31

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.

code-golf  string 
— Brian H.
fonte
— Brian H.
1
Posso pegar x como string?
— precisa saber é o seguinte
o que (-1,1)dá?
— Adám 01/12/19
@ Adám adicionou aos exemplos.
— Brian H.
1
Um +sinal inicial é aceitável para números positivos?
— Tom Carpenter

Respostas:

4

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.

— Shaggy
fonte
Agradável! Você pode economizar um pouco simplesmente mapeando -: ethproductions.github.io/japt/…
— ETHproductions
@ETHproductions: Ótima ligação. Obrigado. Faz tanto tempo desde que eu fiz isso, eu esqueci completamente que você pode dividir, mapear e juntar uma sequência de caracteres em um único método!
— Shaggy
Sim, suponho que a funcionalidade deva ser movida para q, o que seria, então, q-_©ùTVsalvar 1 byte :-)
— ETHproductions
@ETHproductions, se estou entendendo direito, você está sugerindo que, se uma função for passada como um segundo argumento de S.q()(nos fornecer S.q(s,f)), Sela será dividida s, executada fe se juntará a ela s? Eu gosto disso! :)
— Shaggy
Sim, se eu falar com Oliver e não você fazer sobre isso (se passou uma função, fazer a funcionalidade normal, executado através da função, e desfazer a primeira mudança; N.s, S/A.y, N.ìisso já) com um monte de métodos? Eu tive uma conversa com alguém, eu não me lembro quem agora: s
— ETHproductions
6

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
— Emigna
fonte
Parece que esta é a resposta vencedora até agora, se não for melhorada amanhã eu vou aceitá-la.
— Brian H.
você foi derrotado :(
— Brian H.
@BrianH. Na verdade eu tenho :)
— Emigna
5

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

— edc65
fonte
Embora impressionante, sinto que essa resposta contorna as regras um pouco, definindo a função em f(y)(x)vez de f(x,y).
— Styletron
Lendo as regras do "curry", eu queria acrescentar que minha objeção era mais com os parâmetros invertidos e não com o curry em si.
— Styletron #
1
@styletron, a ordem dos parâmetros não está especificada no desafio. Para que eu possa tirar proveito desta
— edc65
Dang, y=>r=x=>x<0?'-'+r(-x):(x+='')[y-1]?x:r(0+x)chega tão perto ...
— ETHproductions
Não tenho problemas com pessoas que estão revertendo a ordem de entrada.
— Brian H.
5

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.
— Zgarb
fonte
5

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.
— duckmayr
fonte
48 bytesfunction(x,y)sprintf(paste0("%0",y+(x<0),"d"),x)
— djhurio
@djhurio shiny! Eu acho que isso justificaria outra resposta em vez de uma edição minha, o que você diz?
— duckmayr
Você pode fazer isso como uma edição. Esta solução não é muito diferente, apenas usando funções diferentes.
— Djhurio 02/12/19
4

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

— Martin Ender
fonte
4

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!
— Charlie
fonte
1
Imprimir -ou nada é realmente fácil no carvão: Imprimir 1 imprime -enquanto imprimir 0 não imprime nada. Portanto, o ternário é supérfluo, economizando 3 bytes.
— Neil
Se você trocar o InputNumber()com o Cast(q), acho que pode mudar para uma comparação de cadeias para salvar outro byte.
— Neil
@ Neil eu sabia que poderia simplificar o Ternary!
— Charlie
4

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 .

— Titus
fonte
Obtendo um erro ao executar o código nesse link.
— Shaggy
@Shaggy A segunda versão requer PHP 7.1
— Titus
Eu continuei falando sobre isso e cheguei exatamente a essa resposta. Eu acredito que esta é a versão ideal
— Ismael Miguel
3

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!

— J42161217
fonte
3

Mathematica, 63 62 bytes

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

Experimente online!

— MatjazGo
fonte
2
Bem-vindo ao PPCG! Eu acho que isso não está fazendo o que você quer. Você provavelmente quis dizer em IntegerLengthvez de IntegerDigits. Você pode salvar um byte usando em IntegerLength@#vez de IntegerLength[#].
— Martin Ender
Obrigado! Eu estava copiando o código de outro computador manualmente, onde o estava testando e, na verdade, digitei incorretamente IntegerDigits for IntegerLength. Deve funcionar agora. Também adicionei um link TIO com todos os casos de teste na descrição do desafio (+1), mostrando que ele funciona conforme o esperado. Obrigado também pela sugestão de salvar um byte extra! Não sei como senti falta disso antes. :)
— MatjazGo 4/17/17
2

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)))
— Wernisch
fonte
Você pode eliminar os )))bytes de -3 convertendo-o no Google Sheets
— Taylor Scott
2

Japonês , 14 12 bytes

Economizou 2 bytes graças a @ETHproductions

s r"%d+"_ù0V

Experimente online

— Oliver
fonte
É um pouco mais barato manter o sinal de menos e mexer nos dígitos: Teste on-line
— ETHproductions
@ETHproductions: Ou use xuma string de 10 bytes .
— Shaggy
@ETHproductions graças pessoal. Vou atualizá-lo quando voltar para minha mesa.
— Oliver
@ Shaggy Parece que você postou sua própria resposta, então usarei o truque da ETHproduction. Obrigado embora.
— Oliver
Oliver, esse 10-byter é apenas a solução de 12 bytes da @ ETHproduction atualizada para Japt 2.0a0 com Uuma string que nos permite jogar com os 2 primeiros caracteres.
— Shaggy
2

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.

— briantist
fonte
Parece que ambos falham quando yé negativo.
— Shaggy
@ Shaggy ugh boa captura. Removida a segunda solução completamente e corrigida a primeira, obrigado!
— Briantist
Ai, 15 bytes! Desculpe!
— Shaggy
@ Shaggy heh, um dia desses vou escrever a linguagem de golfe baseada no PowerShell em que estive pensando. Isso realmente me empurrou para pesquisar um pouco mais e chegar mais perto de iniciá-lo, por isso obrigado por isso;)
— briantist
2

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)));
— user76514
fonte
1

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.

— Conor O'Brien
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.