Giriş

Sol ped npm paketi serpinti sonrasında, sol-pad'i uygulamak için bir kod golfü alalım.

Sol-ped fonksiyonunun içinde, 2 varsayılan argümanları ve 1 ek bağımsız değişken oluşur dizi , uzunluk ( padchar ). Eğer padchar verilmezse, bu bir boşluk karakterine standart hale getirilir . İki argüman ile bir örnek verelim:

left_pad("abc", 6)

İlk önce, dize uzunluğunu 3 olan gözlemleriz . Bundan sonra, tam dizginin uzunluğu işlevinde verilen uzunluğa erişinceye kadar bu dizgiyi sola kaydırmamız gerekir. Bu durumda 6 . Padchar verilmediğinden , bunu boşluklarla doldurmamız gerekir:

   abc

Bu, 3 boşluklu bir dize ve ilk dizedir ve 6 uzunluğunda bir dize oluşturur. İşte verilen padchar örneği:

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

Sadece yukarıdaki örnekle aynı şeyi yapıyoruz, ancak boşlukları padchar ile değiştiriyoruz. Bu durumda, kısa çizgi:

---abc

Görev

Verilen dize , uzunluk ve belki ek argüman padchar , çıkış sol yastıklı dize. Uzunluk sayısının dizenin uzunluğuna eşit veya daha büyük olduğunu varsayabilirsiniz. Padchar her zaman 1 karakterden oluşacaktır.

Test durumları

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"

Bu kod-golf , bu yüzden en küçük bayt sayısına sahip olan gönderim kazanıyor!

Pyth, 13 11 bayt

+*.xwd-Qlzz

Burada dene .

STDIN'den ilk satırdaki dize, ikinci satırdaki uzunluk ve isteğe bağlı olarak üçüncü satırdaki dolgu karakterinden girdi alır.

JavaScript (ES6), 43 bayt

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

JavaScript (ES6), 37 43 44 bayt

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

Ölçek:

> 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

İşlev bildirimini saymak isteyip istemediğinizden emin değilim, bunun satırını yazarım.

Javascript ES6, 35 bayt

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

Dene. Javascript'te şu anda mümkün olan en kısa sınırlama olduğuna inanıyorum.

Python 3, 33 31 29 bayt

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

Yeterince açıksözlü. Beni hatırlattığı için @xnor'a teşekkürlerstr.rjust . : P

Aynı uzunluk için (ayrıca xnor sayesinde):

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

Önceki çözüm:

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

05AB1E , 11 9 bayt

Kod:

g-ð³0@×¹«

Açıklama:

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.

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin .

JavaScript (ES5), 70 bayt

Özyinelemeyi kullanarak ...

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

İlk seferim sadece 57 bayttı:

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

Ancak sadece ilk 2 testi geçti:

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

Ben hala kısa olanı seviyorum, çünkü pratikte sayıları bir string manipülasyon fonksiyonuna geçirmek ihtiyacım olan bir özellik değil.

Mathematica, 13 bayt

StringPadLeft

Yalnızca yerleşik yanıt # 3 (ilk Range, ikinci oldu Surd) Veya daha az yerleşik: (35 bayt)

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

Julia, 4 bayt

lpad

Tüm test durumlarını geçiyor:

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

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

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

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

Javascript (ES6), 55 bayt

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

Boş bir değer dizisi oluşturun ve sürüme katılın.

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

Daha okunaklıdır, ancak returnbirkaç karakter daha ekler.

Bash, 57 Bayt

Parametreler: string width padchar

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

Bir genişlik alanı dizisi yapın .

Her boşluk karakterini padchar'a dönüştürün .

Doldurma sonra dize yazın .

Python, 41 bayt

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

Yerleşik rjust olmadan, 43 bayt:

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

(birisinin yapmasını beklediği şey değil, ama test odasından geçiyor)

Jöle , 12 bayt

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

^{Çok fazla değişken referansı var. Jelly'in yapışkan bir dil olması gerekmiyor mu?}

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

''.padStart.bind

yerleşik ftw! Sadece Firefox 48 ve üzeri sürümlerde çalışır. Bu özellik 12 Mart tarihinde eklenmiş olarak geçerlidir.

Bu gibi giriş alır:

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

Pike , 67 bayt

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

nefes . Boş dize ""değerlendirirtrue . Niye ya!?

karışık karışık karışık karışık karışık Pike çorbası ...

Pyke , 12 bayt (rekabetçi olmayan)

giriş düğümü eklendi, len düğümü üzerinde hata düzeltmesi, görev gönderildikten sonra atanan düğüme varsayılan sonuçları değiştirdi.

\ =zzjl-z*j+

Açıklama:

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

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

Alternatif bir çözüm.

JavaScript (ES6), 34 bayt

Özyinelemeli bir çözüm kullandım.

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

Ruby, 42 bayt

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

Parametreler: string, size, padchar.

Aşağıdaki test paketi; tüm "true" ları yazmalı, her şeyi aynı dosyaya koymalısınız.

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 bayt

Bu bir fonksiyondur. Üçüncü argüman varargsisteğe bağlı ped karakterine izin vermek içindir (varsayılan olarak ' ')

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

Özyineleme! +2 bayt (uyumsuz tür hatası nedeniyle parantez eklendi)

PHP, 54 48 bayt

Windows-1252 kodlamasını kullanır.

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

Böyle koş ( -dyalnızca easthetics için eklendi):

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

Eski versiyon (yerleşik değil):

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

Düzenlemeler

• str_padBir döngü yerine kullanarak 6 bayt kaydedildi . Yerleşikler kaşlarını çattığında eskisini referans için bırakmak

R, 50 bayt

Yine partiye geç kaldı ama işte başlıyor:

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

Bu basitçe çıktıyı stdout'a yazdırır ancak gerçekte yastıklı dizgiyi döndürmez (bunun meydan okuma için bir gereklilik olup olmadığından emin değildi). Bu gerekliyse, çözüm 61 byte'ta biraz daha uzundur:

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

C, 64 bayt

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

Burada dene .