Introdução

Na esteira da esquerda-pad pacote npm precipitação , vamos ter um golf código para a implementação deixou-pad.

A função do teclado esquerdo consiste em 2 argumentos padrão e 1 argumento adicional, no formato string , length , ( padchar ). Se o padchar não for fornecido, isso será padronizado para um caractere de espaço . Vamos dar um exemplo com dois argumentos:

left_pad("abc", 6)

Primeiro, observamos o comprimento da corda, que é 3 . Depois disso, precisamos preencher esta string à esquerda até que o comprimento da string completa atinja o comprimento indicado na função. Nesse caso 6 . Como o padchar não é fornecido , precisamos preenchê- lo com espaços:

   abc

Esta é uma string com 3 espaços e a string inicial, resultando em uma string com comprimento 6. Aqui está um exemplo com o padchar fornecido:

left_pad("abc", 6, "-")

Apenas fazemos o mesmo que o exemplo acima, mas substituímos os espaços pelo padchar. Nesse caso, o hífen:

---abc

A tarefa

Dada a sequência , o comprimento e, talvez, o argumento adicional de argumento , produz a sequência preenchida à esquerda. Você pode supor que o número do comprimento seja igual ou superior ao comprimento da string. O padchar sempre será composto de 1 caractere.

Casos de teste

left_pad("string", length, ("padchar")) === "left-padded string"

left_pad("foo", 5) === "  foo"
left_pad("foobar", 6) === "foobar"
left_pad("1", 2, "0") === "01"
left_pad("1", 2, "-") === "-1"

Isso é código-golfe , então a submissão com o menor número de bytes vence!

Pitão, 13 11 bytes

+*.xwd-Qlzz

Experimente aqui .

Recebe entrada de STDIN como a sequência na primeira linha, o comprimento na segunda linha e o caractere de preenchimento opcionalmente na terceira linha.

JavaScript (ES6), 43 bytes

f=(s,n,p=" ",r=p)=>(r+=s+="")[n]?s:f(r,n,p)

JavaScript (ES6), 37 43 44 bytes

(a,n,c=' ')=>((c+'').repeat(n)+a).substr(-n)

Teste:

> f=(a,n,c)=>((c?c:" ").repeat(n)+a).substr(-n)
< function (a,n,c)=>((c?c:" ").repeat(n)+a).substr(-n)
> f('foo', 5) === '  foo';
< true
> f('foobar', 6) === 'foobar';
< true
> f(1, 2, 0) === '01';
< true
> f(1, 2, '-') === '-1';
< true

Não tenho certeza se você deseja contar a declaração da função, eu inline isso.

Javascript ES6, 35 bytes

(s,l,c=' ')=>c.repeat(l-s.length)+s

Tente. Acredito que esta seja a implementação mais curta possível atualmente em Javascript.

Python 3, 33 31 29 bytes

lambda a,b,x=" ":a.rjust(b,x)

Bastante direto. Graças a @xnor por me lembrar str.rjusté uma coisa. : P

Para o mesmo comprimento (também graças ao xnor):

lambda a,b,x=" ":(x*b+a)[-b:]

Solução anterior:

lambda a,b,x=" ":x*(b-len(a))+a

05AB1E , 11 9 bytes

Código:

g-ð³0@×¹«

Explicação:

g          # Implicit first input, take the length.
 -         # Substract the length with the second input.
  ð³       # Push a space and if the third input exists, also the third input.         
    0@     # Reposition the first element of the stack to the top (zero-indexed).
      ×    # Multiply the character with the difference in length.
       ¹«  # Concatenate the first input to the string.

Usa a codificação CP-1252 . Experimente online .

JavaScript (ES5), 70 bytes

Usando recursão ...

function f(s,c,p,u){return(s+'').length<c?f((p==u?' ':p+'')+s,c,p):s}

Minha partida inicial foi de apenas 57 bytes:

function f(s,c,p){return s.length<c?f((p||" ")+s,c,p):s}

Mas apenas passou nos dois primeiros testes:

> f('foo', 5) === '  foo';
true
> f('foobar', 6) === 'foobar';
true
> f(1, 2, 0) === '01';
false
> f(1, 2, '-') === '-1';
false

Ainda gosto do mais curto, porque, na prática, passar números para uma função de manipulação de string não é um recurso que eu precisaria.

Mathematica, 13 bytes

StringPadLeft

Resposta interna apenas # 3 (a primeira foi Range, a segunda foi Surd) Ou menos incorporada: (35 bytes)

##2~StringRepeat~(#3-Length@#2)<>#&

Julia, 4 bytes

lpad

Passa em todos os casos de teste:

julia> lpad("foo", 5)
"  foo"

julia> lpad("foobar", 6)
"foobar"

julia> lpad(1, 2, 0)
"01"

julia> lpad(1, 2, '-')
"-1"

Javascript (ES6), 55 bytes

(a,n,c=' ',s=a+'')=>(new Array(++n-s.length).join(c)+s)

Crie uma matriz vazia de valores e participe da versão.

(a,n,c=' ')=>{a+=''; return new Array(++n-a.length).join(c)+a}

É mais legível, mas returnadiciona mais alguns caracteres.

Bash, 57 bytes

Parâmetros: largura da cadeia padchar

printf -vX %$2s;Y="${X// /${3- }}$1";echo -n "${Y:${#1}}"

Faça uma sequência de espaços de largura .

Converta cada caractere de espaço em padchar .

Escreva o preenchimento e depois a corda .

Python, 41 bytes

lambda a,b,x=' ':str(a).rjust(b,str(x))

Sem o ajuste interno, 43 bytes:

lambda a,b,x=' ':str(x)*int(b/2%3)+str(a)

(não o que se espera, mas passa no conjunto de testes)

Gelatina , 12 bytes

L⁴_ẋ@⁵⁵⁶<?¤³

^{Tantas referências de variáveis. Jelly não deveria ser uma linguagem tácita ?}

Experimente online!

Como funciona

L⁴_ẋ@⁵⁵⁶<?¤³  Main link
              Arguments: string (³), length (⁴), padchar (⁵, defaults to 10)

L             Compute the length of ³.
 ⁴_           Subtract the length from ⁴.
          ¤   Combine the two links to the left into a niladic chain:
     ⁵          Yield ⁵.
      ⁵⁶<?      Yield ⁵ if ⁵ < ⁵, else ⁶.
              Comparing a number with itself gives 0 (falsy), but comparing a
              string / character list with itself gives [0] (truthy).
   ẋ@         Repeat the result to the right as many times as specified in the
              result to the left.
           ³  Print the previous return value and return ³.

JavaScript ES7, 16 bytes

''.padStart.bind

ftw embutido! Funciona apenas no Firefox 48 e superior. Válido como este recurso foi adicionado em 12 de março.

Isso leva a entrada como:

(''.padStart.bind)(arg1)(arg2,arg3)

Pike , 67 bytes

mixed n(mixed a,int b,mixed x){return x!=""?x:" "*(b-strlen(a))+a;}

suspiro . A cadeia vazia é ""avaliada como true.Por quê!?

misto misto misto misto misto ...

Pyke , 12 bytes (não competitivo)

nó de entrada adicionado, correção de bug no nó len, altere os resultados padrão no nó de atribuição após o lançamento do desafio.

\ =zzjl-z*j+

Explicação:

\ =z         - assign default input for `z` to be " " (Will still prompt but no input will return a space instead)
    zj       -     j = input()
      l      -    len(j)
       -     -   eval_or_not_input() - ^
        z*   -  ^*input()
          j+ - ^+j

JavaScript ES6, 38 bytes

(s,l,c=" ")=>(c.repeat(l)+s).slice(-l)

Uma solução alternativa.

JavaScript (ES6), 34 bytes

Eu usei uma solução recursiva.

f=(s,l,c=' ')=>s[l-1]?s:f(c+s,l,c)

Ruby, 42 bytes

def left_pad(s,t,p=" ");p*(t-s.size)+s;end

Parâmetros: string, tamanho, padchar.

Conjunto de teste abaixo; deve imprimir todos os "verdadeiros", basta colocar tudo no mesmo arquivo.

puts left_pad("foo", 5) == "  foo"
puts left_pad("foobar", 6) == "foobar"
puts left_pad("1", 2, "0") == "01"
puts left_pad("1", 2, "-") == "-1"

Java 8, 86 88 bytes

Esta é uma função. O terceiro argumento é a varargspara permitir o pad pad opcional (o padrão é ' ')

String p(String s,int l,char...p){return s.length()<l?p((p.length>0?p[0]:' ')+s,l,p):s;}

Recursão! +2 bytes (colchetes adicionados devido a erro de tipo incompatível)

PHP, 54 48 bytes

Usa a codificação Windows-1252.

function(&$s,$l,$p=~ß){$s=str_pad($s,$l,$p,0);};

Execute assim ( -dadicionado apenas para easthetics):

php -r '$f = function(&$s,$l,$p=~ß){$s=str_pad($s,$l,$p,0);}; $s="foo";$f($s,5);echo"$s\n";' 2>/dev/null

Versão antiga (sem o builtin):

function(&$s,$l,$p=~ß){for(;strlen($s)<$l;)$s=$p.$s;};

Tweaks

• Economizou 6 bytes usando em str_padvez de um loop. Deixando o antigo para referência, pois os componentes internos são desaprovados

R, 50 bytes

Tarde para a festa novamente, mas aqui vai:

function(s,n,p=" ")cat(rep(p,n-nchar(s)),s,sep="")

Isso simplesmente imprime a saída em stdout, mas na verdade não retorna a string acolchoada (não tinha certeza se isso é um requisito para o desafio). Se isso for necessário, a solução será um pouco mais longa em 61 bytes:

function(s,n,p=" ")paste0(c(rep(p,n-nchar(s)),s),collapse="")

C, 64 bytes

f(s,n,c,p){return memset(p,c,asprintf(&p,"%*s",n,s)-strlen(s));}

Experimente aqui .