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

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

파이썬, 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

자바 스크립트 (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을 int예의 배열로 가져옵니다. 을 사용하여 반복합니다 $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

자바 스크립트, 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

펄, 26 바이트

@Ton Hospel 덕분에 -4 바이트

25 바이트의 코드 + -a플래그

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

로 실행 :

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

(이전 버전의 Perl에서는을 추가해야 할 수도 있습니다 -n)

배쉬, 14

printf %$#d $@

명령 행에 주어진 입력 목록.

여기서 설명 할 것이 많지 않습니다. printf전달 된 인수 수에 따라 내장 기능을 사용 하여 필요한 패딩을 수행하기 만하면됩니다 .

• $# 전달 된 인수 수
• %<n>d 최대 n 개의 선행 공백이있는 정수를 인쇄하는 printf 형식 지정자입니다.
• $@ 전달 된 모든 인수의 목록입니다.
• 형식 지정자는의 각 멤버에 대해 재사용됩니다 $@.

Ideone .

Vim, 19 바이트

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

한 줄에 숫자 목록을 가져옵니다. :set expandtab인기는 있지만 보편적이지 않은 에 의존합니다 .

:right이것을 위해 분명히 사용하고 싶습니다 . 문제는 명령 줄에 줄 수를 얻는 방법입니다. 전통적인 방법은입니다 만 :%ri<C-R>=line('$'), 모든 텍스트는 길다.

더 짧고 진취적인 접근 방식은 일반 모드 !명령을 사용하여 명령 줄을 구성하는 것 입니다. 이상한 해결 방법이 포함되어 파일을 2 줄 확장 한 다음 다시 제거하지만 2 바이트 더 짧아집니다. 그리고 나는 (예를 들어 :%ri+4!) 실제로 얻는 깨지기 쉬운 명령 줄에 충격을 받았지만 실제로 작동합니다.

루비, 40 36 34 바이트

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

더 많은 일을 할 수 있습니다.

람다라고 부릅니다.

설명:

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

길이는 입력 길이와 일치하도록 입력의 각 요소를 왼쪽으로 채 웁니다.

자바 스크립트 (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에서 사용 중입니다. 입력 라인은 3 칸 들여 쓰기됩니다.

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

코 틀린, 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)
    }
}

하스켈, 47 바이트

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

그것은 JavaScript 목록과 같은 문자열 목록에서 문자열 목록까지의 함수입니다. replicate주어진 크기의 목록 (Haskell 문자열은 문자 목록)을 얻을 수 있습니다. 따라서 문제를 대담하게 가정하여 패딩을 생성합니다 (길이는 N-<length of element>입니다). 입력 목록). 나는 printf이것과 함께 기반 솔루션 을 사용하는 것을 선호 replicate했지만 (단 하나 더 짧았을 것임) import 문은 함수 자체에서 수행 한 모든 절감 효과를 없애줍니다.

자바, 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[]것을 수용 할 수 있습니다 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에서 사용해보십시오.

@KevinCruijssen 덕분에 -1 바이트.

그루비, 36 바이트

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

문자열 배열 만 취하고 채워진 문자열 배열을 출력합니다.

MATL, 14 바이트

'%%%dd'inYDGYD

MATL Online 에서 사용해보십시오

먼저 형식 문자열을 구성하여 형식이 지정된 문자열 작성을 %(NUM)d사용하고이 형식 문자열과 입력을 사용하여 문자열 형식을 다시 적용합니다.

자바 스크립트 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를 가져와 a List<string>를 출력합니다 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="")