introduzione

Sulla scia del pacchetto npm con pad di sinistra fallout del un codice golf per l'implementazione del pad sinistro.

La funzione pad sinistro è composta da 2 argomenti predefiniti e 1 argomento aggiuntivo, nella forma stringa , lunghezza , ( padchar ). Se non viene fornito il padchar, questo è standardizzato per un carattere spazio . Facciamo un esempio con due argomenti:

left_pad("abc", 6)

Innanzitutto, osserviamo la lunghezza della stringa, che è 3 . Dopodiché, dobbiamo riempire questa stringa a sinistra fino a quando la lunghezza della stringa completa non ha raggiunto la lunghezza indicata nella funzione. In questo caso 6 . Poiché il padchar non viene fornito , dobbiamo riempire questo con spazi:

   abc

Questa è una stringa con 3 spazi e la stringa iniziale, risultante in una stringa con lunghezza 6. Ecco un esempio con il padchar dato:

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

Facciamo semplicemente lo stesso dell'esempio sopra, ma sostituiamo gli spazi con il padchar. In questo caso, il trattino:

---abc

L'obiettivo

Data la stringa , la lunghezza e forse l'argomento padchar aggiuntivo, genera la stringa con riempimento a sinistra. Puoi presumere che il numero di lunghezza sia uguale o maggiore della lunghezza della stringa. Il padchar sarà sempre composto da 1 carattere.

Casi test

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"

Questo è code-golf , quindi vince l'invio con il minor numero di byte!

Pyth, 13 11 byte

+*.xwd-Qlzz

Provalo qui .

Prende input da STDIN come stringa sulla prima riga, lunghezza sulla seconda riga e padding char su una terza riga.

JavaScript (ES6), 43 byte

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

JavaScript (ES6), 37 43 44 byte

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

Test:

> 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

Non sono sicuro che tu voglia contare la dichiarazione di funzione, la inline.

Javascript ES6, 35 byte

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

Provalo. Credo che questa sia l'implementazione più breve possibile attualmente in Javascript.

Python 3, 33 31 29 byte

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

Abbastanza semplice. Grazie a @xnor per avermelo ricordato str.rjustè una cosa. : P

Per la stessa lunghezza (anche grazie a xnor):

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

Soluzione precedente:

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

05AB1E , 11 9 byte

Codice:

g-ð³0@×¹«

Spiegazione:

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.

Utilizza la codifica CP-1252 . Provalo online .

JavaScript (ES5), 70 byte

Utilizzo della ricorsione ...

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

Il mio tentativo iniziale era di soli 57 byte:

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

Ma ha superato solo i primi 2 test:

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

Mi piace ancora quello più corto, perché in pratica, passare i numeri a una funzione di manipolazione delle stringhe non è una caratteristica di cui avrei bisogno.

Mathematica, 13 byte

StringPadLeft

Risposta n. 3 solo incorporata (prima era Range, seconda era Surd) O meno incorporata: (35 byte)

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

Julia, 4 byte

lpad

Passa tutti i casi di test:

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

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

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

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

Javascript (ES6), 55 byte

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

Crea una matrice vuota di valori e unisciti alla versione.

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

È più leggibile ma returnaggiunge alcuni caratteri in più.

Bash, 57 byte

Parametri: larghezza della stringa padchar

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

Crea una stringa di spazi di larghezza .

Converti ogni personaggio spaziale in padchar .

Scrivi padding quindi stringa .

Python, 41 byte

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

Senza rjust incorporato, 43 byte:

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

(non quello che ci si aspetta che faccia, ma passa la suite di test)

Gelatina , 12 byte

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

^{Così tanti riferimenti variabili. Jelly non doveva essere una lingua tacita ?}

Provalo online!

Come funziona

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 byte

''.padStart.bind

built-in ftw! Funziona solo su Firefox 48 e versioni successive. Valido in quanto questa funzione è stata aggiunta il 12 marzo.

Questo richiede input come:

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

Pike , 67 byte

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

sospiro . La stringa vuota ""restituisce true. Perché!?

zuppa di luccio mista mista mista mista

Pyke, 12 bytes (noncompeting)

aggiunto nodo di input, correzione di bug sul nodo len, modifica dei risultati predefiniti su nodo di assegnazione dopo la pubblicazione della sfida.

\ =zzjl-z*j+

Spiegazione:

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

An alternate solution.

JavaScript (ES6), 34 bytes

I used a recursive solution.

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

Parameters: string, size, padchar.

Test suite below; should print all "true"s, just put everything in the same file.

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

This is a function. The third argument is a varargs to allow the optional pad char (defaults to ' ')

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

Recursion! +2 bytes (added brackets because of incompatible type error)

PHP, 54 48 bytes

Uses Windows-1252 encoding.

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

Run like this (-d added for easthetics only):

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

Old version (without the builtin):

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

Tweaks

• Saved 6 bytes by using str_pad instead of a loop. Leaving the old one for reference, as builtins are frowned upon

R, 50 bytes

Late to the party again but here it goes:

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

This simply prints the output to stdout but does not actually return the padded string (wasn't sure if this is a requirement for the challenge). If this is needed, the solution is slightly longer at 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));}

Try it here.