NNegatif olmayan tamsayıların bir listesi verildiğinde , bu sayıları her biri boşlukla dolup taşan bir uzunluğa çıkarın N. (Alternatif olarak, bir karakter / dize listesi döndürün.) Listedeki en büyük sayının basamak sayısından büyük veya bu sayıya eşit olduğunu varsayabilirsiniz N. Çıktıda sondaki boşluklara izin verilir.

Bu sayıları içeren bir dize de alabilirsiniz, ancak Ndizenin uzunluğu değil, listedeki öğelerin sayısıdır; Ayrıca, dizelerin bir listesini de alabilirsiniz ["1", "2", "3"].

Bu bir kod golfü, bu yüzden bayttaki en kısa program kazanıyor.

Test senaryoları

input => 'output'
0 => '0'
1 => '1'
2 3 => ' 2 3'
2 10 => ' 210'
4 5 6 => '  4  5  6'
17 19 20 => ' 17 19 20'
7 8 9 10 => '   7   8   9  10'
100 200 300 0 => ' 100 200 300   0'
1000 400 30 7 => '1000 400  30   7'
1 33 333 7777 => '   1  33 3337777'
0 0 0 0 0 0 => '     0     0     0     0     0     0'

05AB1E , 3 bayt

Kod:

Dgj

Açıklama:

D    # Duplicate the input array
 g   # Get the length 
  j  # Left-pad with spaces to the length of the array

Çevrimiçi deneyin! veya Tüm test senaryolarını doğrulayın .

Python, 32 bayt

lambda l:'%%%ds'%len(l)*len(l)%l

Bir parçayı giriş olarak alan anonim bir işlev. Sayılar veya dizeler çalışır.

Örnek:

l=(1,33,333,7777)

'%%%ds'
## A "second-order" format string

'%%%ds'%len(l)           -> '%4s'
## Inserts the length as a number in place of '%d'
## The escaped '%%' becomes '%', ready to take a new format argument
## The result is a format string to pad with that many spaces on the left

'%%%ds'%len(l)*len(l)    -> '%4s%4s%4s%4s'
## Concatenates a copy per element

'%%%ds'%len(l)*len(l)%l  -> '   1  33 3337777'
## Inserts all the tuple elements into the format string 
## So, each one is padded with spaces

JavaScript (ES7), 37 bayt

a=>a.map(v=>v.padStart(a.length,' '))

Girdi: Dizgiler dizisi
Çıktı: Dizgiler dizisi

f=
  a=>a.map(v=>v.padStart(a.length,' '))
;
console.log(f(['0']))
console.log(f(['1']))
console.log(f(['2','3']))
console.log(f(['2','10']))
console.log(f(['4','5','6']))
console.log(f(['17','19','20']))
console.log(f(['7','8','9','10']))
console.log(f(['100','200','300','0']))
console.log(f(['1000','400','30','7']))
console.log(f(['1','33','333','7777']))
console.log(f(['0','0','0','0','0','0']))

PowerShell v2 +, 36 bayt

param($a)$a|%{"{0,$($a.count)}"-f$_}

Girişi $abir dizi dizisi olarak intalır. Onlarla birlikte döngüler $a|%{...}. Her bir yineleme, uygun sayıda boşluğun sol -ftarafını doldurmak için isteğe bağlı Alignment Component(tabanlı $a.count) ormat operatörünü kullanır . Ortaya çıkan dize boru hattında bırakılır. Program yürütme sonunda, ortaya çıkan dizelerin tümü bir dizi olarak boru hattında kalır.

Örnekler

Write-OutputBir dizinin program tamamlanmasında varsayılan değer olduğu için çıktı her çalışmada yeni satırla ayrılır .

PS C:\Tools\Scripts\golfing> @(0),@(1),@(2,3),@(2,10),@(4,5,6),@(17,19,20),@(7,8,9,10),@(100,200,300,0),@(1000,400,30,7),@(1,33,333,7777),@(0,0,0,0,0,0)|%{""+($_-join',')+" -> ";(.\spaced-out-numbers $_)}
0 -> 
0
1 -> 
1
2,3 -> 
 2
 3
2,10 -> 
 2
10
4,5,6 -> 
  4
  5
  6
17,19,20 -> 
 17
 19
 20
7,8,9,10 -> 
   7
   8
   9
  10
100,200,300,0 -> 
 100
 200
 300
   0
1000,400,30,7 -> 
1000
 400
  30
   7
1,33,333,7777 -> 
   1
  33
 333
7777
0,0,0,0,0,0 -> 
     0
     0
     0
     0
     0
     0

JavaScript, 49 bayt

a=>a.map(n=>" ".repeat(a.length-n.length)+n)

Bağımsız değişkenleri bir dize listesi olarak alır ve ayrıca bir dize listesi döndürür.

Açıklama:

a=>                                                   An unnamed function, which takes one argument, a
   a.map(n=>                               )          Do the following to each element n in a:
            " ".repeat(a.length-n.length)             Generate the spaces needed to justify the number
                                         +n           Append the number

Perl, 26 bayt

@Ton Hospel sayesinde -4 bayt

25 bayt kod + -abayrak.

printf"%*s",~~@F,$_ for@F

Şununla çalıştır:

perl -ae 'printf"%*s",~~@F,$_ for@F' <<< "10 11 12"

(Perl'in bazı eski sürümlerinde eklemeniz gerekebilir -n)

Bash, 14

printf %$#d $@

Komut satırında verilen giriş listesi.

Burada açıklanacak fazla bir şey yok. printfGeçilen argümanların sayısına göre gerekli dolguları yapmak için yerleşik tesisleri kullanır :

• $# geçirilen argüman sayısı
• %<n>d n adede kadar boşluk içeren bir tam sayı yazdıran bir printf biçimi belirleyicisidir
• $@ geçirilen tüm argümanların listesi
• Biçim belirleyicisi, öğesinin her üyesi için yeniden kullanılır $@.

Ideone .

Vim, 19 bayt

YPPG!{<C-F>|R%ri<CR>djVGgJ

Satır başına bir sayı listesi alır. Güveniyor :set expandtabpopüler, ama evrensel olmadığı,.

Bunun için açıkça kullanmak istiyorsunuz :right. Soru, satır sayısının komut satırına nasıl alınacağıdır. Geleneksel yöntem :%ri<C-R>=line('$'), ancak tüm bu metin uzun.

Daha kısa, daha girişimci yaklaşım, normal mod !komutunu kullanarak komut satırını oluşturmaktır . Bazı garip geçici çözümler içerir, dosyayı 2 satır genişletir ve tekrar kaldırır, ancak 2 bayt daha kısa ortaya çıkar. Ve :%ri+4!aslında çalıştığım bozuk komut satırını gerçekten şok ediyorum , ama işe yarıyor.

Yakut, 40 36 34 bayt

->m{m.map{|i|$><<i.rjust(m.size)}}

Daha üzerinde çalışılabilir.

Lambda olarak arayın.

Açıklama:

->m{m.map{|i|$><<i.rjust(m.size)}}
->m{                             } # lambda taking array m
    m.map{|i|                   }  # map over array using variable i
             $><<                  # output to $> (stdout)
                 i.rjust(m.size)   # right justify i to m's length

Jöle , 7 6 bayt

L⁶xaUU

Girdi bir dize dizisidir. Çevrimiçi deneyin! veya tüm test senaryolarını doğrulayın .

Nasıl çalışır

L⁶xaUU  Main link. Argument: A (array of strings)

L       Yield the l, the length of A.
 ⁶x     Repeat ' ' l times.

    U   Upend; reverse all strings in A.
   a    Perform vectorizing logical AND, replacing spaces with their corresponding
        digits and leaving spaces without corresponding digits untouched.
     U  Upend; reverse the strings in the result to restore the original order of
        its digits, moving the spaces to the left.

Mathematica, 25 bayt

#~StringPadLeft~Length@#&

Hem giriş hem de çıkış dizelerin listeleridir.

açıklama

Length@#

Girişin uzunluğunu alın (eleman sayısı).

#~StringPadLeft~...

Ped, girişlerdeki her bir öğeyi, uzunlukları girişin uzunluğuna uyacak şekilde bıraktı.

JavaScript (ES6), 47

Anonim işlev, giriş: dizeler dizisi, çıktı: dizeler dizisi
Özyinelemeli dolgu işlevi kullanma

a=>a.map(x=>p(x),p=x=>x[a.length-1]?x:p(' '+x))

Giriş olarak bir tamsayı / dize dizisi için 49 bayt:

a=>a.map(x=>p(x),p=x=>(y=' '+x)[a.length]?x:p(y))

Ölçek

f=
a=>a.map(x=>p(x),p=x=>x[a.length-1]?x:p(' '+x))

function update() {
  var l=I.value.match(/\d+/g)||[]
  O.textContent = f(l)
}

update()
 

<input id=I oninput='update()' value='1000,400,30,7'>
<pre id=O></pre>

PHP, 55 Bayt

<?foreach($a=$_GET[a]as$i)printf("%".count($a)."s",$i);

Pevious Version 59 Bayt

<?foreach($a=$_GET[a]as$i)echo str_pad($i,count($a)," ",0);

J, 4 bayt

":~#

Çevrimiçi deneyin!

Tekli fonksiyon, sağdaki sayı listesini bir dizi olarak alarak yastıklı dizeyi döndürür.

Burada REPL'de kullanılıyor. Giriş satırlarının üç boşluk girintili olduğuna dikkat edin.

   f=: ":~#
   f 2 3
 2 3
   f 2 10
 210
   f 1111 222 33 4
1111 222  33   4

CJam , 11 bayt

lS%_,f{Se[}

Çevrimiçi deneyin! (Test paketi olarak.)

açıklama

l      e# Read input.
S%     e# Split around spaces.
_,     e# Copy and get length.
f{     e# Map this block over the list, passing in the length on each iteration.
  Se[  e#   Left-pad to the given length with spaces.
}

Kotlin, 90 bayt

golfed:

fun main(a:Array<String>){a.forEach{b->for(i in 1..a.size-b.length){print(" ")};print(b)}}

Ungolfed:

fun main(a: Array<String>) {
    a.forEach { b ->
        for (i in 1..a.size - b.length) {
            print(" ")
        }
        print(b)
    }
}

Haskell, 47 bayt

k=length
f l=map(\s->replicate(k l-k s)' '++s)l

Bu, bir dizi listesinden JavaScript yanıtları gibi bir dize listesine bir işlevdir. replicatebiri belirli bir boyutta bir liste (Haskell dizeleri karakter listeleridir) almak için izin verir, bu yüzden Nher öğe için dolgu oluşturmak için uzunluğu (uzunluğu - öğenin uzunluğu>), - ve sorundaki kalın varsayım - kullanın giriş listesinin). Ben bunun printfyerine tabanlı bir çözüm kullanmayı tercih ederdim replicate(bir şey için daha kısa olurdu) ama ithalat beyanı fonksiyonun kendisi üzerinde yapılan herhangi bir tasarrufu öldürür.

Java, 83 82 bayt

a->{String s="";for(int i=a.length,j=i;i-->0;)s+="%"+j+"s";return s.format(s,a);};

Verilen bağımsız değişkenleri dizinin uzunluğuna eşit sayıda boşlukla doldurmak için tasarlanmış bir biçim dizesi oluşturur. Biçim dizesi için bağımsız değişken olarak kullanılır String.formatve sonuç döndürülür. Fonksiyonel arayüz a String[]veya a Integer[]veya benzerlerini kabul edebilir .

Tam sınıf:

public class Test {
    public static void main(String[] args) {
        java.util.function.Function<Integer[], String> f = a -> {
            String s = "";
            for (int i = a.length, j = i; i-- > 0;)
                s += "%" + j + "s";
            return s.format(s, a);
        };

        System.out.println(f.apply(new Integer[] {0}));
        System.out.println(f.apply(new Integer[] {2, 10}));
        System.out.println(f.apply(new Integer[] {7, 8, 9, 10}));
        System.out.println(f.apply(new Integer[] {1, 33, 333, 7777}));
        System.out.println(f.apply(new Integer[] {0, 0, 0, 0, 0, 0}));
    }
}

Ideone üzerinde deneyin.

@KevinCruijssen sayesinde -1 bayt.

Groovy, 36 Bayt

{a->a.collect{it.padLeft(a.size())}}

Yalnızca dizeleri alır, dizili dizeleri çıkarır.

MATL, 14 bayt

'%%%dd'inYDGYD

MATL Online'da deneyin

Bu, önce biçim dizesini oluşturarak biçimlendirilmiş dize oluşturma kullanır: %(NUM)dve sonra bu biçim dizesini ve girdiyi kullanarak dize biçimlendirmesini tekrar uygular.

JavaScript 33 bayt

@Hedi benzeri - ancak varsayılan dolgu '', bu yüzden 4 karakter daha az

a=>a.map(s=>s.padStart(a.length))

f=a=>a.map(s=>s.padStart(a.length))

console.log(f(["0"]))
console.log(f(["1"]))
console.log(f(["2","3"]))
console.log(f(["2","10"]))
console.log(f(["17" ,"19" ,"2"]))
console.log(f(["1000" ,"400" ,"30" ,"7"]))

K (oK) , 11 bayt

Çözüm:

,/(-#x)$$x:

Çevrimiçi deneyin!

Açıklama:

Sağdan sola yorumlandı. Dizeye dönüştürün ve liste uzunluğu ile sol yüzeyini düzeltin:

,/(-#x)$$x: / the solution                      | example:
         x: / save as 'x'                       |
        $   / string                            | $10 20 30 -> "10","20","30"
       $    / pad right by left                 | 5$"abc" -> "abc  "
  (   )     / do the stuff in brackets together |
    #x      / count x                           | #10 20 30 -> 3
   -        / negate                            |
,/          / flatten (concatenate-over)        | ,/" a"," b"," c" -> " a b c"

Pyth - 7 bayt

Dolgu yerleşik kullanarak doğrudan cevap.

sm.[;lQ

Test Takımı .

C #, 39 bayt

s=>s.ConvertAll(c=>c.PadLeft(s.Count));

A alır List<string>ve çıkarır a List<string>.

Açıklama:

/*Func<List<string>, List<string>> Lambda =*/ s =>
    s.ConvertAll(c =>                                // Create a new List<string> by...
        c.PadLeft(s.Count)                           // ...padding each element by 'N'
    )
;

İçe aktarma sayılmazsa ve IEnumerable<string>tam bir liste yerine geri dönerse, LINQ kullanmak için birkaç bayt daha kısa olurdu :

C #, 35 + 18 = 53 bayt

using System.Linq;s=>s.Select(c=>c.PadLeft(s.Count));

R, 47 bayt

cat(sprintf("%*.f",length(n<-scan()),n),sep="")

Stdin'den girdi okur ve C stili biçimlendirmeyi kullanır sprintf. İşleve gerek catduyulmadığı bir yol olmalı, ancak her öğedeki tırnak işaretleri olmadan bastırmanın bir yolunu bulamamalıyız. Yalnızca başlangıç ​​ve bitiş tırnakları istiyorsak biraz daha uzun seçeneği kullanabiliriz:

paste0(sprintf("%*.f",length(n<-scan()),n),collapse="")