Đưa ra một danh sách các Nsố nguyên không âm, xuất các số đó với mỗi số được đệm bởi các khoảng trắng theo chiều dài N. (Hoặc, trả về danh sách ký tự / chuỗi.) Bạn có thể giả sử rằng Nlớn hơn hoặc bằng số chữ số của số lớn nhất trong danh sách. Không gian lưu trữ được cho phép trong đầu ra.

Bạn cũng có thể lấy một chuỗi chứa các số này, nhưng Nkhông phải là độ dài của chuỗi, mà là số phần tử trong danh sách; Ngoài ra, bạn có thể lấy một danh sách các chuỗi, ví dụ ["1", "2", "3"].

Đây là một môn đánh gôn, vì vậy chương trình ngắn nhất tính bằng byte sẽ thắng.

Các trường hợp thử nghiệm

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 byte

Mã số:

Dgj

Giải trình:

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

Hãy thử trực tuyến! hoặc Xác minh tất cả các trường hợp thử nghiệm .

Python, 32 byte

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

Một hàm ẩn danh lấy một tuple làm đầu vào. Số hoặc chuỗi hoạt động.

Thí dụ:

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 byte

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

Đầu vào: Mảng chuỗi
Đầu ra: Mảng chuỗi

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 byte

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

Đưa đầu vào $anhư một mảng của integers. Vòng qua chúng với $a|%{...}. Mỗi lần lặp, sử dụng -ftoán tử ormat với tùy chọn Alignment Component(dựa trên $a.count) để đệm bên trái số lượng khoảng trống thích hợp. Chuỗi kết quả đó được để lại trên đường ống. Khi kết thúc thực hiện chương trình, các chuỗi kết quả được để lại trên đường ống dưới dạng một mảng.

Ví dụ

Đầu ra được phân tách dòng mới trên mỗi lần chạy, vì đó là mặc định Write-Outputkhi hoàn thành chương trình cho một mảng.

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 byte

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

Lấy các đối số dưới dạng một danh sách các chuỗi và cũng trả về một danh sách các chuỗi.

Giải trình:

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 byte

-4 byte nhờ @TonMedel

25 byte mã + -acờ.

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

Chạy với:

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

(Trên một số phiên bản cũ hơn của Perl, bạn có thể cần thêm -n)

Bash, 14

printf %$#d $@

Danh sách đầu vào được đưa ra tại dòng lệnh.

Không có nhiều để giải thích ở đây. Đơn giản chỉ cần sử dụng các printftiện ích tích hợp để thực hiện phần đệm cần thiết, dựa trên số lượng đối số được thông qua:

• $# là số lượng args được thông qua
• %<n>d là một công cụ xác định định dạng printf in một số nguyên có tối đa n không gian hàng đầu
• $@ là danh sách của tất cả các đối số được thông qua
• Trình xác định định dạng được sử dụng lại cho mỗi thành viên của $@.

Ideone .

Vim, 19 byte

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

Đưa ra một danh sách các số một dòng trên mỗi dòng. Dựa vào :set expandtab, đó là phổ biến, nhưng không phổ quát.

Bạn rõ ràng muốn sử dụng :rightcho việc này. Câu hỏi là làm thế nào để có được số lượng dòng trên dòng lệnh. Cách truyền thống là:%ri<C-R>=line('$') , nhưng tất cả các văn bản đó là dài.

Cách tiếp cận ngắn hơn, táo bạo hơn là hình thành dòng lệnh bằng cách sử dụng !lệnh chế độ bình thường . Nó liên quan đến một số cách giải quyết kỳ lạ, mở rộng tệp bằng 2 dòng sau đó xóa chúng một lần nữa, nhưng nó xuất hiện ngắn hơn 2 byte. Và tôi hơi sốc khi dòng lệnh bị cắt xén tôi nhận được (như :%ri+4!) thực sự hoạt động, nhưng nó có.

Ruby, 40 36 34 byte

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

Có thể được làm việc trên nhiều hơn.

Gọi như một lambda.

Giải trình:

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

Thạch , 7 6 byte

L⁶xaUU

Đầu vào là một chuỗi các chuỗi. Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

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.

Toán học, 25 byte

#~StringPadLeft~Length@#&

Cả đầu vào và đầu ra là danh sách các chuỗi.

Giải trình

Length@#

Lấy độ dài của đầu vào (số phần tử).

#~StringPadLeft~...

Pad để lại mỗi phần tử trong đầu vào sao cho độ dài của chúng khớp với độ dài của đầu vào.

JavaScript (ES6), 47

Hàm ẩn danh, đầu vào: mảng chuỗi, đầu ra: mảng chuỗi
Sử dụng chức năng đệm đệ quy

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

Đối với một mảng số nguyên / chuỗi làm đầu vào, 49 byte:

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

Kiểm tra

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 byte

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

Phiên bản có giá trị 59 byte

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

J, 4 byte

":~#

Hãy thử trực tuyến!

Hàm unary lấy danh sách các số ở bên phải dưới dạng một mảng và trả về chuỗi đệm.

Đây là nó được sử dụng tại REPL. Lưu ý rằng các dòng đầu vào được thụt vào ba khoảng trắng.

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

CJam , 11 byte

lS%_,f{Se[}

Hãy thử trực tuyến! (Là một bộ thử nghiệm.)

Giải trình

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 byte

Chơi gôn

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

Ung dung:

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

Haskell, 47 byte

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

Đó là một hàm từ danh sách các chuỗi đến danh sách các chuỗi, như các câu trả lời JavaScript. replicatecho phép một người có được danh sách (chuỗi Haskell là danh sách các ký tự) có kích thước nhất định, vì vậy tôi sử dụng nó - và giả định được in đậm trong bài toán - để tạo phần đệm (độ dài của nó là N- <độ dài của phần tử>, cho mỗi phần tử của danh sách đầu vào). Tôi muốn sử dụng một printfgiải pháp dựa trên hơn là giải pháp dựa trên replicate(vì nó sẽ ngắn hơn, vì một điều) nhưng câu lệnh nhập sẽ giết bất kỳ khoản tiết kiệm nào được thực hiện trên chính chức năng đó.

Java, 83 82 byte

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

Xây dựng một chuỗi định dạng được thiết kế để đệm các đối số đã cho bằng một số khoảng trắng bằng với độ dài của mảng. Chuỗi định dạng được sử dụng làm đối số cho String.formatvà kết quả được trả về. Giao diện chức năng có thể chấp nhận một String[]hoặc một Integer[]hoặc tương tự.

Toàn lớp:

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

Hãy thử nó trên Ideone.

-1 byte nhờ @KevinCruijssen.

Groovy, 36 byte

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

Chỉ thực hiện trong chuỗi các chuỗi, xuất ra mảng các chuỗi đệm.

MATL, 14 byte

'%%%dd'inYDGYD

Dùng thử tại MATL Online

Điều này sử dụng tạo chuỗi được định dạng bằng cách trước tiên xây dựng chuỗi định dạng: %(NUM)dvà sau đó áp dụng định dạng chuỗi một lần nữa bằng cách sử dụng chuỗi định dạng này và đầu vào.

JavaScript 33 byte

tương tự như @Hedi - nhưng phần đệm mặc định là '', vì vậy 4 ký tự của nó ít hơn

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 byte

Dung dịch:

,/(-#x)$$x:

Hãy thử trực tuyến!

Giải trình:

Giải thích từ phải sang trái. Chuyển đổi thành chuỗi và phím trái với độ dài của danh sách, sau đó làm phẳng:

,/(-#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 byte

Câu trả lời đơn giản bằng cách sử dụng phần đệm dựng sẵn.

sm.[;lQ

Phòng thử nghiệm .

C #, 39 byte

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

Đưa List<string>ra và xuất ra mộtList<string> .

Giải trình:

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

Sẽ có một vài byte ngắn hơn để sử dụng LINQ nếu quá trình nhập không được tính và sau đó quay lại IEnumerable<string> thay vì danh sách đầy đủ:

C #, 35 + 18 = 53 byte

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

R, 47 byte

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

Đọc đầu vào từ stdin và sử dụng định dạng kiểu C với sprintf. Cần có một số cách mà catchức năng không cần thiết nhưng không thể tìm ra cách để loại bỏ các trích dẫn trên mỗi thành phần mà không có nó. Nếu chúng tôi chỉ muốn báo giá bắt đầu và kết thúc, chúng tôi có thể sử dụng tùy chọn dài hơn một chút:

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