Dada uma lista de Nnúmeros inteiros não negativos, imprima esses números com cada um preenchido à esquerda por espaços com um comprimento de N. (Como alternativa, retorne uma lista de caracteres / sequência.) Você pode assumir que Nseja maior ou igual ao número de dígitos do maior número na lista. Espaços à direita são permitidos na saída.

Você também pode Nusar uma string contendo esses números, mas não é o comprimento da string, mas o número de elementos na lista; Além disso, você pode fazer uma lista de strings, por exemplo ["1", "2", "3"].

Este é um código de golfe, portanto o programa mais curto em bytes vence.

Casos de teste

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 bytes

Código:

Dgj

Explicação:

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

Experimente online! ou Verifique todos os casos de teste .

Python, 32 bytes

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

Uma função anônima que usa uma tupla como entrada. Números ou seqüências de caracteres funcionam.

Exemplo:

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 bytes

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

Entrada: matriz de cadeias
Saída: matriz de cadeias

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 bytes

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

Recebe entrada $acomo uma matriz de integers. Loops através deles com $a|%{...}. Cada iteração usa o -foperador ormat com o opcional Alignment Component(com base em $a.count) para colocar à esquerda o número apropriado de espaços. Essa sequência resultante é deixada no pipeline. No final da execução do programa, as seqüências resultantes são todas deixadas no pipeline como uma matriz.

Exemplos

A saída é separada por nova linha em cada execução, pois esse é o padrão Write-Outputna conclusão do programa para uma matriz.

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 bytes

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

Toma os argumentos como uma lista de cadeias e também retorna uma lista de cadeias.

Explicação:

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 bytes

-4 bytes graças a @Ton Hospel

25 bytes de código + -asinalizador.

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

Correr com :

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

(Em alguma versão mais antiga do Perl, você pode precisar adicionar -n)

Bash, 14

printf %$#d $@

Lista de entrada fornecida na linha de comando.

Não há muito a explicar aqui. Simplesmente usa printfrecursos internos para fazer o preenchimento necessário, com base no número de argumentos passados:

• $# é o número de argumentos passados
• %<n>d é um especificador de formato printf que imprime um número inteiro com até n espaços à esquerda
• $@ é a lista de todos os argumentos passados
• O especificador de formato é reutilizado para cada membro de $@.

Ideone .

Vim, 19 bytes

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

Leva uma lista de números um por linha. Confia no :set expandtabque é popular, mas não universal.

Você deseja claramente usar :rightisso. A questão é como obter o número de linhas na linha de comando. A maneira tradicional é :%ri<C-R>=line('$'), mas todo esse texto é longo.

A abordagem mais curta e empreendedora é formar a linha de comando usando o !comando no modo normal . Envolve algumas soluções estranhas, expandindo o arquivo em 2 linhas e removendo-os novamente, mas sai 2 bytes mais curto. E eu estou chocado com a linha de comando distorcida que eu recebo (como :%ri+4!) realmente funciona, mas funciona.

Ruby, 40 36 34 bytes

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

Pode ser trabalhado em mais.

Ligue como um lambda.

Explicação:

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

Geléia , 7 6 bytes

L⁶xaUU

Entrada é uma matriz de seqüências de caracteres. Experimente online! ou verifique todos os casos de teste .

Como funciona

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 bytes

#~StringPadLeft~Length@#&

Tanto a entrada quanto a saída são listas de strings.

Explicação

Length@#

Obtenha o comprimento da entrada (número de elemento).

#~StringPadLeft~...

O pad deixou cada elemento na entrada para que seus comprimentos correspondam ao comprimento da entrada.

JavaScript (ES6), 47

Função anônima, entrada: matriz de cadeias, saída: matriz de cadeias
Usando uma função de preenchimento recursivo

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

Para uma matriz de número inteiro / sequência como entrada, 49 bytes:

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

Teste

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 bytes

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

Versão anterior 59 bytes

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

J, 4 bytes

":~#

Experimente online!

Função unária, pegando a lista de números à direita como uma matriz e retornando a string preenchida.

Aqui está em uso no REPL. Observe que as linhas de entrada são recuadas em três espaços.

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

CJam , 11 bytes

lS%_,f{Se[}

Experimente online! (Como uma suíte de teste.)

Explicação

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 bytes

Golfe:

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 bytes

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

Essa é uma função de uma lista de cadeias de caracteres para uma lista de cadeias de caracteres, como as respostas do JavaScript. replicatepermite obter uma lista (seqüências de caracteres Haskell são listas de caracteres) de um determinado tamanho, então eu a uso - e a suposição em negrito no problema - para gerar o preenchimento (seu comprimento é N- <comprimento do elemento>, para cada elemento da lista de entrada). Eu preferiria usar uma printfsolução baseada em vez de uma solução replicate(ela teria sido mais curta, por um lado), mas a instrução de importação mata todas as economias feitas na própria função.

Java, 83 82 bytes

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

Constrói uma string de formato projetada para preencher os argumentos fornecidos por um número de espaços iguais ao comprimento da matriz. A sequência de formato é usada como argumento para String.formate o resultado é retornado. A interface funcional pode aceitar um String[]ou um Integer[]ou similar.

Classe completa:

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

Experimente em Ideone.

-1 byte graças a @KevinCruijssen.

Groovy, 36 bytes

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

Recebe apenas uma matriz de seqüências de caracteres, gera uma matriz de seqüências de caracteres acolchoadas.

MATL, 14 bytes

'%%%dd'inYDGYD

Experimente no MATL Online

Isso usa a criação de cadeia de caracteres formatada construindo primeiro a cadeia de formato: %(NUM)de depois aplica a formatação de cadeia novamente usando essa cadeia de formato e a entrada.

JavaScript 33 bytes

semelhante ao @Hedi - mas o preenchimento padrão é '', portanto, seus 4 caracteres a menos

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 bytes

Solução:

,/(-#x)$$x:

Experimente online!

Explicação:

Interpretada da direita para a esquerda. Converta em string e mantenha o teclado esquerdo com o comprimento da lista e achatar:

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

Pitão - 7 bytes

Resposta direta usando o preenchimento interno.

sm.[;lQ

Conjunto de Teste .

C #, 39 bytes

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

Pega a List<string>e produz a List<string>.

Explicação:

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

Seriam alguns bytes mais curtos para usar o LINQ se a importação não fosse contada e retornasse em IEnumerable<string>vez de uma lista completa:

C #, 35 + 18 = 53 bytes

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

R, 47 bytes

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

Lê a entrada do stdin e usa formatação no estilo C com sprintf. Deve haver alguma maneira de a catfunção não ser necessária, mas não foi possível encontrar uma maneira de suprimir as aspas de cada elemento sem ela. Se quisermos apenas cotações de início e de final, poderíamos usar a opção um pouco mais longa:

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