Dato un elenco di Nnumeri interi non negativi, genera quei numeri con ciascuno di essi riempito a sinistra di spazi per una lunghezza di N. (In alternativa, restituisce un elenco di caratteri / stringhe.) Si può presumere che Nsia maggiore o uguale al numero di cifre del numero più grande nell'elenco. Gli spazi finali sono consentiti nell'output.

Puoi anche prendere una stringa contenente questi numeri, ma Nnon è la lunghezza della stringa, ma piuttosto il numero di elementi nell'elenco; inoltre, è possibile prendere un elenco di stringhe, ad es ["1", "2", "3"].

Questo è un codice-golf, quindi vince il programma più breve in byte.

Casi test

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

Codice:

Dgj

Spiegazione:

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

Provalo online! oppure Verifica tutti i casi di test .

Python, 32 byte

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

Una funzione anonima che accetta una tupla come input. Numeri o stringhe funzionano.

Esempio:

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,' '))

Input: matrice di stringhe
Output: matrice di stringhe

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

Accetta input $acome una matrice di integers. Passa attraverso di loro con $a|%{...}. Ogni iterazione utilizza l' -foperatore ormat con l'opzione facoltativa Alignment Component(basata su $a.count) per spostare a sinistra il numero appropriato di spazi. La stringa risultante viene lasciata sulla pipeline. Alla fine dell'esecuzione del programma, le stringhe risultanti vengono lasciate sulla pipeline come un array.

Esempi

L'output è separato da una nuova riga a ogni esecuzione, poiché è l'impostazione predefinita Write-Outputal completamento del programma per un array.

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)

Prende gli argomenti come un elenco di stringhe e restituisce anche un elenco di stringhe.

Spiegazione:

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 grazie a @Ton Hospel

25 byte di codice + -aflag.

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

Corri con :

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

(Su alcune versioni precedenti di Perl, potresti dover aggiungere -n)

Bash, 14

printf %$#d $@

Elenco di input fornito nella riga di comando.

Non c'è molto da spiegare qui. Utilizza semplicemente le strutture integrate printfper eseguire il riempimento necessario, in base al numero di argomenti passati:

• $# è il numero di argomenti passati
• %<n>d è un identificatore di formato printf che stampa un numero intero con un massimo di n spazi iniziali
• $@ è l'elenco di tutti gli arg passati
• L'identificatore di formato viene riutilizzato per ciascun membro di $@.

Ideone .

Vim, 19 byte

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

Prende un elenco di numeri uno per riga. Conta su:set expandtab , che è popolare, ma non universale.

Vuoi chiaramente usarlo :rightper questo. La domanda è come ottenere il numero di righe sulla riga di comando. Il modo tradizionale è:%ri<C-R>=line('$') , ma tutto quel testo è lungo.

L'approccio più breve e più intraprendente è quello di formare la riga di comando utilizzando il !comando modalità normale . Implica alcune strane soluzioni alternative, espandendo il file di 2 righe e rimuovendole di nuovo, ma risulta più corto di 2 byte. E sono un po 'scioccato che la riga di comando confusa che ottengo (mi piace :%ri+4!) funzioni davvero, ma lo fa.

Rubino, 40 36 34 byte

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

Si può lavorare di più.

Chiama come lambda.

Spiegazione:

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

L⁶xaUU

L'input è una matrice di stringhe. Provalo online! o verifica tutti i casi di test .

Come funziona

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 byte

#~StringPadLeft~Length@#&

Sia l'input che l'output sono elenchi di stringhe.

Spiegazione

Length@#

Ottieni la lunghezza dell'input (numero di elementi).

#~StringPadLeft~...

Il pad ha lasciato ciascun elemento nell'input in modo che la sua lunghezza corrisponda alla lunghezza dell'input.

JavaScript (ES6), 47

Funzione anonima, input: array di stringhe, output: array di stringhe
Utilizzo di una funzione di imbottitura ricorsiva

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

Per un array di numeri interi / stringhe come input, 49 byte:

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

Test

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

Pevious versione 59 byte

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

J, 4 byte

":~#

Provalo online!

Funzione unaria che prende l'elenco di numeri a destra come un array e restituisce la stringa imbottita.

Qui è in uso presso il REPL. Si noti che le righe di input sono rientrate di tre spazi.

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

Provalo online! (Come una suite di test.)

Spiegazione

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

golfed:

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 byte

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

Questa è una funzione da un elenco di stringhe a un elenco di stringhe, come le risposte JavaScript. replicateconsente di ottenere un elenco (le stringhe di Haskell sono elenchi di caratteri) di una determinata dimensione, quindi lo uso - e il presupposto in grassetto nel problema - per generare il riempimento (la sua lunghezza è N- <lunghezza dell'elemento>, per ogni elemento dell'elenco di input). Avrei preferito usare una printfsoluzione basata piuttosto che questa con replicate(sarebbe stata più breve, per prima cosa) ma la dichiarazione di importazione uccide qualsiasi risparmio fatto sulla funzione stessa.

Java, 83 82 byte

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

Costruisce una stringa di formato progettata per riempire gli argomenti dati di un numero di spazi pari alla lunghezza dell'array. La stringa di formato viene utilizzata come argomento per String.formate il risultato viene quindi restituito. L'interfaccia funzionale può accettare una String[]o una Integer[]o simile.

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

Provalo su Ideone.

-1 byte grazie a @KevinCruijssen.

Groovy, 36 byte

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

Accetta solo array di stringhe, genera array di stringhe imbottite.

MATL, 14 byte

'%%%dd'inYDGYD

Provalo su MATL Online

Questo utilizza la creazione di stringhe formattate costruendo prima la stringa di formato: %(NUM)dquindi applica nuovamente la formattazione della stringa utilizzando questa stringa di formato e l'input.

JavaScript 33 byte

simile a @Hedi - ma il padding predefinito è '', quindi i suoi 4 caratteri in meno

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

Soluzione:

,/(-#x)$$x:

Provalo online!

Spiegazione:

Interpretato da destra a sinistra. Converti in stringa e pad sinistro con lunghezza dell'elenco, quindi appiattisci:

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

Risposta semplice utilizzando l'imbottitura integrata.

sm.[;lQ

Test Suite .

C #, 39 byte

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

Prende a List<string>e genera a List<string>.

Spiegazione:

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

Sarebbe stato più breve di qualche byte utilizzare LINQ se l'importazione non fosse conteggiata e quindi restituita IEnumerable<string>anziché un elenco completo:

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="")

Legge l'input da stdin e utilizza la formattazione in stile C con sprintf. Dovrebbe esserci un modo in cui la catfunzione non è necessaria ma non è possibile trovare un modo per sopprimere le virgolette su ciascun elemento senza di essa. Se vogliamo solo virgolette di inizio e fine, potremmo usare l'opzione leggermente più lunga:

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