Einführung

Lassen Sie uns nach dem Fallout des npm-Pakets mit dem linken Pad einen Code für die Implementierung des linken Pads erstellen.

Die Funktion für das linke Feld besteht aus 2 Standardargumenten und 1 zusätzlichen Argument in der Form Zeichenfolge , Länge ( padchar ). Wenn das Padchar nicht angegeben ist, wird dies auf ein Leerzeichen standardisiert . Nehmen wir ein Beispiel mit zwei Argumenten:

left_pad("abc", 6)

Zuerst beobachten wir die Länge der Zeichenkette, die 3 ist . Danach müssen wir diese Zeichenfolge links auffüllen, bis die Länge der vollständigen Zeichenfolge die in der Funktion angegebene Länge erreicht hat. In diesem Fall 6 . Da das Padchar nicht angegeben ist , müssen wir dieses mit Leerzeichen auffüllen :

   abc

Dies ist eine Zeichenfolge mit 3 Leerzeichen und der Anfangszeichenfolge, die zu einer Zeichenfolge mit der Länge 6 führt. Hier ist ein Beispiel mit dem angegebenen Padchar:

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

Wir machen einfach dasselbe wie im obigen Beispiel, ersetzen jedoch die Leerzeichen durch das Padchar. In diesem Fall lautet der Bindestrich:

---abc

Die Aufgabe

Geben Sie unter Berücksichtigung der Zeichenfolge , der Länge und möglicherweise des zusätzlichen Argumentes padchar die links aufgefüllte Zeichenfolge aus. Sie können davon ausgehen, dass die Länge gleich oder größer als die Länge der Zeichenfolge ist. Das Padchar besteht immer aus 1 Zeichen.

Testfälle

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"

Das ist Code-Golf , also gewinnt die Einsendung mit der geringsten Anzahl von Bytes!

Pyth, 13 11 Bytes

+*.xwd-Qlzz

Probieren Sie es hier aus .

Übernimmt die Eingabe von STDIN als Zeichenfolge in der ersten Zeile, die Länge in der zweiten Zeile und optional das Füllzeichen in einer dritten Zeile.

JavaScript (ES6), 43 Byte

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)

Prüfung:

> 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

Ich bin mir nicht sicher, ob Sie die Funktionsdeklaration zählen möchten.

Javascript ES6, 35 Bytes

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

Versuch es. Ich glaube, dies ist die kürzestmögliche Implementierung, die derzeit in Javascript möglich ist.

Python 3, 33 31 29 Bytes

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

Ziemliech direkt. Danke an @xnor , dass du mich str.rjustdaran erinnert hast . : P

Bei gleicher Länge (auch dank xnor):

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

Vorherige Lösung:

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

05AB1E , 11 9 Bytes

Code:

g-ð³0@×¹«

Erläuterung:

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.

Verwendet die CP-1252- Codierung. Probieren Sie es online aus .

JavaScript (ES5), 70 Byte

Rekursion verwenden ...

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

Mein erster Versuch war nur 57 Bytes:

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

Hat aber erst die ersten 2 Tests bestanden:

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

Ich mag immer noch die kürzere, weil ich in der Praxis keine Funktion benötige, um Zahlen an eine Zeichenfolgenmanipulationsfunktion zu übergeben.

Mathematica, 13 Bytes

StringPadLeft

Eingebaute Antwort # 3 (erste war Range, zweite war Surd) oder weniger eingebaut: (35 Bytes)

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

Julia, 4 Bytes

lpad

Besteht alle Testfälle:

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)

Erstellen Sie ein leeres Array von Werten und verbinden Sie die Version.

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

Ist besser lesbar, returnfügt aber noch ein paar Zeichen hinzu.

Bash, 57 Bytes

Parameter: Stringbreite padchar

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

Bilden Sie eine Schnur der Breite .

Wandle jedes Leerzeichen in padchar um .

Schreibe padding und dann string .

Python, 41 Bytes

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

Ohne das eingebaute Recht, 43 Bytes:

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

(nicht das, was man erwartet, aber es besteht die Testsuite)

Gelee , 12 Bytes

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

^{So viele variable Referenzen. Sollte Jelly nicht eine stillschweigende Sprache sein?}

Probieren Sie es online!

Wie es funktioniert

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

eingebaute ftw! Funktioniert nur mit Firefox 48 und höher. Gültig, da diese Funktion am 12. März hinzugefügt wurde.

Dies erfordert Eingaben wie:

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

Hecht , 67 Bytes

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

Seufzer . Die leere Zeichenfolge ""ergibt true. Warum!?

gemischt gemischt gemischt gemischt gemischt Hechtsuppe ...

Pyke , 12 Bytes (nicht konkurrierend)

Input Node hinzugefügt, Bugfix auf Len Node, Standardergebnisse auf Assign Node ändern nachdem die Challenge gepostet wurde.

\ =zzjl-z*j+

Erläuterung:

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

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

Eine alternative Lösung.

JavaScript (ES6), 34 Byte

Ich habe eine rekursive Lösung verwendet.

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

Parameter: string, size, padchar.

Testsuite unten; sollten alle "true" s drucken, stecke einfach alles in die selbe datei.

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

Dies ist eine Funktion. Das dritte Argument ist a varargs, um das optionale Pad-Zeichen zuzulassen (Standardeinstellung ist ' ').

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

Rekursion! +2 Bytes (Klammern wegen inkompatiblem Typfehler hinzugefügt)

PHP, 54 48 Bytes

Verwendet die Windows-1252-Codierung.

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

Laufen Sie wie folgt (-d folgt (nur für Easthetics hinzugefügt):

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

Alte Version (ohne das eingebaute):

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

Optimierungen

• 6 Bytes mit str_padanstelle einer Schleife gespeichert . Lassen Sie die alte als Referenz, da Builtins verpönt sind

R, 50 Bytes

Wieder zu spät zur Party, aber hier ist es:

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

Dies druckt einfach die Ausgabe auf stdout, gibt aber nicht die aufgefüllte Zeichenfolge zurück (war nicht sicher, ob dies eine Anforderung für die Herausforderung ist). In diesem Fall ist die Lösung mit 61 Byte etwas länger:

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

Probieren Sie es hier aus .