introduction

Dans le sillage des retombées du paquet npm de gauche , ayons un code golf pour implémenter le gauche pad.

La fonction de gauche-pad se compose de 2 arguments par défaut et 1 argument supplémentaire, sous la forme de chaîne , longueur , ( padchar ). Si le padchar n'est pas donné, il est normalisé en un caractère espace . Prenons un exemple avec deux arguments:

left_pad("abc", 6)

Tout d'abord, nous observons la longueur de la chaîne, qui est 3 . Après cela, nous devons remplir cette chaîne à gauche jusqu'à ce que la longueur de la chaîne complète ait atteint la longueur indiquée dans la fonction. Dans ce cas 6 . Puisque le padchar n'est pas donné , nous devons le remplir avec des espaces:

   abc

Il s'agit d'une chaîne avec 3 espaces et la chaîne initiale, résultant en une chaîne de longueur 6. Voici un exemple avec le padchar donné:

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

Nous faisons juste la même chose que l'exemple ci-dessus, mais remplaçons les espaces par le padchar. Dans ce cas, le tiret:

---abc

La tâche

Étant donné la chaîne , la longueur et peut - être l'argument supplémentaire padchar , affichez la chaîne remplie à gauche. Vous pouvez supposer que le numéro de longueur est égal ou supérieur à la longueur de la chaîne. Le padchar sera toujours composé d'un caractère.

Cas de 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"

C'est du code-golf , donc la soumission avec le plus petit nombre d'octets gagne!

Pyth, 13 11 octets

+*.xwd-Qlzz

Essayez-le ici .

Prend l'entrée de STDIN comme chaîne sur la première ligne, longueur sur la deuxième ligne et caractère de remplissage éventuellement sur une troisième ligne.

JavaScript (ES6), 43 octets

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

JavaScript (ES6), 37 43 44 octets

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

Tester:

> 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

Je ne sais pas si vous voulez compter la déclaration de fonction, je l'inline.

Javascript ES6, 35 octets

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

Essayez-le. Je crois que c'est l'implémentation la plus courte possible actuellement possible en Javascript.

Python 3, 33 31 29 octets

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

Assez simple. Merci à @xnor de me le rappeler str.rjustest une chose. : P

Pour la même longueur (également grâce à xnor):

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

Solution précédente:

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

05AB1E , 11 9 octets

Code:

g-ð³0@×¹«

Explication:

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.

Utilise l' encodage CP-1252 . Essayez-le en ligne .

JavaScript (ES5), 70 octets

Utilisation de la récursivité ...

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

Ma tentative initiale n'était que de 57 octets:

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

Mais seulement réussi les 2 premiers tests:

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

J'aime toujours le plus court, car dans la pratique, passer des nombres à une fonction de manipulation de chaîne n'est pas une fonctionnalité dont j'aurais besoin.

Mathematica, 13 octets

StringPadLeft

Réponse intégrée n ° 3 (la première était Range, la seconde était Surd) Ou moins intégrée: (35 octets)

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

Julia, 4 octets

lpad

Réussit tous les cas de 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 octets

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

Créez un tableau de valeurs vide et joignez la version.

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

Est plus lisible mais returnajoute quelques caractères supplémentaires.

Bash, 57 octets

Paramètres: largeur de chaîne padchar

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

Faites une chaîne d' espaces de largeur .

Convertissez chaque caractère d'espace en padchar .

Écrivez le remplissage puis la chaîne .

Python, 41 octets

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

Sans le droit intégré, 43 octets:

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

(pas ce que l'on attend de lui, mais il passe la suite de tests)

Gelée , 12 octets

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

^{Tant de références variables. Jelly n'était-il pas censé être une langue tacite ?}

Essayez-le en ligne!

Comment ça marche

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 octets

''.padStart.bind

ftw intégré! Fonctionne uniquement sur Firefox 48 et supérieur. Valide car cette fonctionnalité a été ajoutée le 12 mars.

Cela prend une entrée comme:

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

Brochet , 67 octets

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

soupir . La chaîne vide est ""évaluée à true. Pourquoi!?

mixte mixte mixte mixte mixte soupe de brochet ...

Pyke , 12 octets (non compétitif)

ajout du nœud d'entrée, correction de bugs sur le nœud len, modification des résultats par défaut sur l'affectation du nœud après la publication du défi.

\ =zzjl-z*j+

Explication:

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

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

Une solution alternative.

JavaScript (ES6), 34 octets

J'ai utilisé une solution récursive.

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

Rubis, 42 octets

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

Paramètres: chaîne, taille, padchar.

Suite de tests ci-dessous; devrait imprimer tous les "vrais", il suffit de tout mettre dans le même fichier.

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 octets

Ceci est une fonction. Le troisième argument est a varargspour autoriser le caractère optionnel du pad (par défaut ' ')

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

Récursivité! +2 octets (crochets ajoutés en raison d'une erreur de type incompatible)

PHP, 54 48 octets

Utilise l'encodage Windows-1252.

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

Courez comme ceci ( -dajouté pour l'esthétique uniquement):

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

Ancienne version (sans le intégré):

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

Tweaks

• Enregistré 6 octets en utilisant str_padau lieu d'une boucle. Laissant l'ancien pour référence, car les éditeurs sont mal vus

R, 50 octets

Retard à la fête, mais c'est parti:

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

Cela imprime simplement la sortie sur stdout mais ne retourne pas réellement la chaîne rembourrée (je ne savais pas si c'était une exigence pour le défi). Si cela est nécessaire, la solution est légèrement plus longue à 61 octets:

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

C, 64 octets

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

Essayez-le ici .