Dada una lista de Nenteros no negativos, emite esos números con espacios rellenados a la izquierda por una longitud de N. (Alternativamente, devuelva una lista de caracteres / cadenas). Puede suponer que Nes mayor o igual que el número de dígitos del número más grande en la lista. Se permiten espacios finales en la salida.

También puede tomar una cadena que contenga estos números, pero Nno es la longitud de la cadena, sino el número de elementos en la lista; Además, puede tomar una lista de cadenas, por ejemplo ["1", "2", "3"].

Este es un código de golf, por lo que gana el programa más corto en bytes.

Casos de prueba

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

Explicación:

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

Pruébalo en línea! o Verificar todos los casos de prueba .

Python, 32 bytes

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

Una función anónima que toma una tupla como entrada. Los números o las cadenas funcionan.

Ejemplo:

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 cadenas
Salida: matriz de cadenas

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$_}

Toma entrada $acomo una matriz de integers. Los recorre con ellos $a|%{...}. Cada iteración usa el -foperador ormat con el opcional Alignment Component(basado en $a.count) para rellenar con la izquierda el número apropiado de espacios. Esa cadena resultante se deja en la tubería. Al final de la ejecución del programa, las cadenas resultantes se dejan en la tubería como una matriz.

Ejemplos

La salida se separa en línea nueva en cada ejecución, ya que ese es el valor predeterminado Write-Outputal finalizar el programa para una 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 los argumentos como una lista de cadenas y también devuelve una lista de cadenas.

Explicació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 bytes

-4 bytes gracias a @Ton Hospel

25 bytes de código + -abandera.

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

Corre con :

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

(En algunas versiones anteriores de Perl, es posible que deba agregar -n)

Bash, 14

printf %$#d $@

Lista de entrada dada en la línea de comando.

No hay mucho que explicar aquí. Simplemente utiliza las funciones integradas printfpara hacer el relleno necesario, basado en el número de argumentos pasados:

• $# es el número de args pasados
• %<n>d es un especificador de formato printf que imprime un número entero con hasta n espacios iniciales
• $@ es la lista de todos los argumentos pasados
• El especificador de formato se reutiliza para cada miembro de $@.

Ideone .

Vim, 19 bytes

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

Toma una lista de números uno por línea. Se basa en :set expandtab, que es popular, pero no universal.

Claramente quieres usar :rightpara esto. La pregunta es cómo obtener el número de líneas en la línea de comando. La forma tradicional es :%ri<C-R>=line('$'), pero todo ese texto es largo.

El enfoque más corto y más emprendedor es formar la línea de comando usando el !comando de modo normal . Implica algunas soluciones extrañas, expandir el archivo en 2 líneas y luego eliminarlas nuevamente, pero sale 2 bytes más corto. Y estoy un poco sorprendido de que la línea de comando ilegible que obtengo (como :%ri+4!) realmente funcione, pero lo hace.

Ruby, 40 36 34 bytes

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

Se puede trabajar en más.

Llama como una lambda.

Explicación:

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

Gelatina , 7 6 bytes

L⁶xaUU

La entrada es una matriz de cadenas. Pruébalo en línea! o verificar todos los casos de prueba .

Cómo 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 la entrada como la salida son listas de cadenas.

Explicación

Length@#

Obtenga la longitud de la entrada (número de elemento).

#~StringPadLeft~...

Pad dejó cada elemento en la entrada para que sus longitudes coincidan con la longitud de la entrada.

JavaScript (ES6), 47

Función anónima, entrada: matriz de cadenas, salida: matriz de cadenas
Usando una función de relleno recursiva

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

Para una matriz de enteros / cadenas como entrada, 49 bytes:

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

Prueba

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

Versión anterior 59 bytes

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

J, 4 bytes

":~#

Pruébalo en línea!

Función unaria que toma la lista de números de la derecha como una matriz y devuelve la cadena rellenada.

Aquí está en uso en el REPL. Tenga en cuenta que las líneas de entrada tienen sangría en tres espacios.

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

Pruébalo en línea! (Como un conjunto de pruebas).

Explicación

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

Golfizado:

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

Sin golf:

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

Esa es una función de una lista de cadenas a una lista de cadenas, como las respuestas de JavaScript. replicatepermite obtener una lista (las cadenas de Haskell son listas de caracteres) de un tamaño determinado, por lo que la uso, y la suposición en negrita en el problema, para generar el relleno (su longitud es N- <longitud del elemento>, para cada elemento de la lista de entrada). Hubiera preferido utilizar una printfsolución basada en lugar de esta con replicate(habría sido más corta, por un lado), pero la declaración de importación elimina cualquier ahorro realizado en la función en sí.

Java, 83 82 bytes

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

Construye una cadena de formato diseñada para rellenar los argumentos dados por un número de espacios igual a la longitud de la matriz. La cadena de formato se utiliza como argumento para String.format, y luego se devuelve el resultado. La interfaz funcional puede aceptar a String[]o an Integer[]o similar.

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

Pruébalo en Ideone.

-1 byte gracias a @KevinCruijssen.

Groovy, 36 Bytes

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

Toma solo una matriz de cadenas, emite una matriz de cadenas acolchadas.

MATL, 14 bytes

'%%%dd'inYDGYD

Pruébelo en MATL Online

Esto utiliza la creación de cadenas formateadas al construir primero la cadena de formato: %(NUM)dy luego aplica el formato de cadena nuevamente usando esta cadena de formato y la entrada.

JavaScript 33 bytes

similar a @Hedi, pero el relleno predeterminado es '', por lo que sus 4 caracteres 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

Solución:

,/(-#x)$$x:

Pruébalo en línea!

Explicación:

Interpretado de derecha a izquierda. Convierte a cadena y pad izquierdo con la longitud de la lista, luego aplana:

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

Respuesta directa con relleno incorporado.

sm.[;lQ

Test Suite .

C #, 39 bytes

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

Toma a List<string>y saca a List<string>.

Explicación:

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

Hubiera sido unos pocos bytes más cortos para usar LINQ si la importación no se cuenta y luego regresa en IEnumerable<string>lugar de una 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="")

Lee la entrada de stdin y usa el formateo de estilo C con sprintf. Debería haber alguna forma en que la catfunción no sea necesaria, pero no podría encontrar una forma de suprimir las comillas en cada elemento sin ella. Si solo queremos cotizaciones de inicio y fin, podríamos usar la opción un poco más larga:

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