Introducción

A raíz de las consecuencias del paquete npm del pad izquierdo , tengamos un código de golf para implementar el pad izquierdo.

La función de pad izquierdo consta de 2 argumentos predeterminados y 1 argumento adicional, en forma de cadena , longitud , ( padchar ). Si no se proporciona el padchar, se estandariza a un carácter de espacio . Tomemos un ejemplo con dos argumentos:

left_pad("abc", 6)

Primero, observamos la longitud de la cuerda, que es 3 . Después de esto, necesitamos rellenar esta cadena a la izquierda hasta que la longitud de la cadena completa haya alcanzado la longitud dada en la función. En este caso 6 . Como no se proporciona el padchar , debemos rellenar esto con espacios:

   abc

Esta es una cadena con 3 espacios y la cadena inicial, que resulta en una cadena con longitud 6. Aquí hay un ejemplo con el padchar dado:

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

Simplemente hacemos lo mismo que en el ejemplo anterior, pero reemplazamos los espacios con el padchar. En este caso, el guión:

---abc

La tarea

Dada la cadena , la longitud y tal vez el argumento adicional padchar , genera la cadena con relleno izquierdo. Puede suponer que el número de longitud es igual o mayor que la longitud de la cadena. El padchar siempre constará de 1 personaje.

Casos de prueba

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"

Este es el código de golf , por lo que gana el envío con el menor número de bytes.

Pyth, 13 11 bytes

+*.xwd-Qlzz

Probar aquí .

Toma información de STDIN como la cadena en la primera línea, la longitud en la segunda línea y el relleno de caracteres opcionalmente en una tercera línea.

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)

Prueba:

> 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

No estoy seguro si desea contar la declaración de función, lo incluiría en línea.

Javascript ES6, 35 bytes

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

Intentalo. Creo que esta es la implementación más corta posible actualmente en Javascript.

Python 3, 33 31 29 bytes

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

Bastante sencillo. Gracias a @xnor por recordarme que str.rjustes una cosa. :PAGS

Para la misma longitud (también gracias a xnor):

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

Solución previa:

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

05AB1E , 11 9 bytes

Código:

g-ð³0@×¹«

Explicación:

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.

Utiliza la codificación CP-1252 . Pruébalo en línea .

JavaScript (ES5), 70 bytes

Usando la recursividad ...

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

Mi primer intento fue de solo 57 bytes:

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

Pero solo pasó las 2 primeras pruebas:

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

Todavía me gusta el más corto, porque en la práctica, pasar números a una función de manipulación de cadenas no es una característica que necesitaría.

Mathematica, 13 bytes

StringPadLeft

Respuesta integrada solo # 3 (primero fue Range, segundo fue Surd) O menos integrada: (35 bytes)

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

Julia, 4 bytes

lpad

Pasa todos los casos de prueba:

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)

Cree una matriz vacía de valores y una versión de unión.

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

Es más legible pero returnagrega algunos caracteres más.

Bash, 57 Bytes

Parámetros: ancho de cadena padchar

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

Haz una cadena de espacios de ancho .

Convierte cada personaje espacial en padchar .

Escriba el relleno y luego la cadena .

Python, 41 bytes

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

Sin el rjust incorporado, 43 bytes:

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

(no es lo que uno espera que haga, pero pasa el conjunto de pruebas)

Jalea , 12 bytes

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

^{Tantas referencias variables. ¿No se suponía que Jelly era un lenguaje tácito ?}

Pruébalo en línea!

Cómo 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

incorporados ftw! Solo funciona en Firefox 48 y superior. Válido ya que esta característica se agregó el 12 de marzo.

Esto toma datos como:

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

Lucio , 67 bytes

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

suspiro . La cadena vacía se ""evalúa como true. ¿¡Por qué!?

mixto mixto mixto mixto mixto sopa de lucio ...

Pyke , 12 bytes (sin competencia)

nodo de entrada agregado, corrección de errores en el nodo len, cambiar los resultados predeterminados en el nodo de asignación después de que se publicó el desafío.

\ =zzjl-z*j+

Explicación:

\ =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)

Una solución alternativa.

JavaScript (ES6), 34 bytes

Usé una solución 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: cuerda, tamaño, padchar.

Conjunto de pruebas a continuación; debería imprimir todos los "verdaderos", simplemente ponga todo en el mismo archivo.

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 es una función. El tercer argumento es varargspara permitir el pad opcional char (el valor predeterminado es ' ')

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

Recursión! +2 bytes (corchetes agregados debido a un error de tipo incompatible)

PHP 54 48 bytes

Utiliza la codificación de Windows-1252.

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

Ejecutar así ( -dagregado solo 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

Versión anterior (sin el incorporado):

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

Ajustes

• Guardado 6 bytes mediante el uso en str_padlugar de un bucle. Dejando el viejo como referencia, ya que las construcciones están mal vistas

R, 50 bytes

Tarde a la fiesta otra vez pero aquí va:

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

Esto simplemente imprime la salida en stdout pero en realidad no devuelve la cadena acolchada (no estaba seguro de si este es un requisito para el desafío). Si esto es necesario, la solución es un poco más larga a 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));}

Pruébalo aquí .