给定一个N非负整数列表，输出这些数字，每个数字用空格左填充，长度为N。（或者，返回一个字符/字符串列表。）您可以假定该N数字大于或等于列表中最大数字的位数。输出中允许尾随空格。

您也可以使用包含这些数字N的字符串，但不是字符串的长度，而是列表中元素的数量。同样，您可以获取字符串列表，例如["1", "2", "3"]。

这是一个代码高尔夫球，因此以字节为单位的最短程序获胜。

测试用例

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个字节

码：

Dgj

说明：

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

在线尝试！或验证所有测试用例。

Python，32个字节

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

以元组为输入的匿名函数。数字或字符串均可。

例：

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个字节

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

输入：字符串
数组输出：字符串数组

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个字节

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

将输入$a作为integers 数组。通过循环遍历它们$a|%{...}。每次迭代都使用-format运算符和可选的Alignment Component（基于$a.count）左键填充适当数量的空格。该结果字符串留在管道上。在程序执行结束时，结果字符串将作为数组留在管道上。

例子

每次运行时输出均以换行符分隔，因为这Write-Output是数组程序完成时的默认设置。

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个字节

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

将参数作为字符串列表，还返回字符串列表。

说明：

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个字节

-4个字节，感谢@Ton Hospel

25个字节的代码+ -a标志。

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

运行：

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

（在某些旧版本的Perl上，您可能需要添加-n）

Bash，14岁

printf %$#d $@

在命令行中给出的输入列表。

这里没有太多解释。只需使用内置的printf工具，根据传递的args的数量进行必要的填充：

• $# 是传递的参数个数
• %<n>d 是printf格式说明符，可打印最多n个前导空格的整数
• $@ 是所有传递的参数列表
• 格式说明符可用于的每个成员$@。

伊迪奥。

Vim，19个字节

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

每行一个数字列表。依靠:set expandtab，这很流行，但并不通用。

您显然想为此使用:right。问题是如何在命令行上获取行数。传统方式是:%ri<C-R>=line('$')，但是所有文字都很长。

一种更短，更进取的方法是使用常规模式!命令来形成命令行。它涉及一些怪异的解决方法，将文件扩展2行，然后再次将其删除，但结果要短2个字节。而且我有点震惊我得到的乱码命令行（例如:%ri+4!）实际上可以工作，但是确实可以。

Ruby，40 36 34字节

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

可以做更多的工作。

调用为lambda。

说明：

->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

果冻，7 6 字节

L⁶xaUU

输入是一个字符串数组。在线尝试！或验证所有测试用例。

怎么运行的

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个字节

#~StringPadLeft~Length@#&

输入和输出都是字符串列表。

说明

Length@#

获取输入的长度（元素数）。

#~StringPadLeft~...

Pad保留输入中的每个元素的长度，以使其长度与输入的长度匹配。

JavaScript（ES6），47

匿名函数，输入：字符串数组，输出：字符串数组
使用递归填充函数

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

对于整数/字符串数组作为输入，为49个字节：

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

测试

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字节

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

先前版本59字节

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

J，4个字节

":~#

在线尝试！

一元函数，将右边的数字列表作为数组并返回填充的字符串。

REPL正在使用它。请注意，输入行缩进了三个空格。

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

CJam，11个字节

lS%_,f{Se[}

在线尝试！（作为测试套件。）

说明

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个字节

打高尔夫球：

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

取消高尔夫：

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

Haskell，47个字节

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

这是一个从字符串列表到字符串列表的函数，例如JavaScript答案。replicate允许获取给定大小的列表（Haskell字符串是字符列表），因此我使用它以及问题中的粗体假设N为每个元素生成填充（其长度为− <元素的长度>）输入列表）。我宁愿使用printf基于解决方案的解决方案，而不是使用此解决方案replicate（一方面，它会更短），但是import语句会杀死对函数本身所做的任何节省。

Java，83 82字节

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

构造一个格式字符串，该格式字符串用于将给定参数填充等于数组长度的空格。格式字符串用作的参数String.format，然后返回结果。功能接口可以接受a String[]或an Integer[]或类似名称。

全班：

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上尝试。

-1个字节感谢@KevinCruijssen。

Groovy，36字节

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

仅接受字符串数组，输出填充字符串数组。

MATL，14个字节

'%%%dd'inYDGYD

在MATL Online上试用

这首先通过构造格式字符串来使用格式字符串创建：%(NUM)d然后使用此格式字符串和输入再次应用字符串格式。

JavaScript 33字节

类似于@Hedi-但默认填充为''，因此少了4个字符

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个字节

解：

,/(-#x)$$x:

在线尝试！

说明：

从右到左解释。转换为字符串，然后左键拖动列表长度，然后展平：

,/(-#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个字节

使用内置的填充直接回答。

sm.[;lQ

测试套件。

C＃，39个字节

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

取a List<string>并输出a List<string>。

说明：

/*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'
    )
;

如果不计入导入次数，然后返回IEnumerable<string>而不是完整列表，使用LINQ的时间将缩短几个字节：

C＃，35 + 18 = 53字节

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

R，47个字节

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

从stdin读取输入，并使用带有C样式的格式sprintf。应该有一些cat不需要该函数的方法，但是找不到该函数可以抑制每个元素上的引号。如果我们只想使用引号和结尾引号，则可以使用稍长的选项：

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