Geben Sie bei einer Liste Nnicht negativer Ganzzahlen diese Zahlen mit jeweils mit Leerzeichen auf einer Länge von links aufgefüllt aus N. (Alternativ können Sie eine Zeichen- / Zeichenkettenliste zurückgeben.) Sie können davon ausgehen, dass diese Ngrößer oder gleich der Anzahl der Stellen der größten Zahl in der Liste ist. Nachgestellte Leerzeichen sind in der Ausgabe zulässig.

Sie können auch eine Zeichenfolge verwenden, die diese Zahlen enthält. Dabei handelt es sich jedoch Nnicht um die Länge der Zeichenfolge, sondern um die Anzahl der Elemente in der Liste. Sie können auch eine Liste von Zeichenfolgen verwenden, z ["1", "2", "3"].

Dies ist ein Code-Golf, also gewinnt das kürzeste Programm in Bytes.

Testfälle

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

Code:

Dgj

Erläuterung:

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

Probieren Sie es online! oder Überprüfen Sie alle Testfälle .

Python, 32 Bytes

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

Eine anonyme Funktion, die ein Tupel als Eingabe verwendet. Entweder funktionieren Zahlen oder Zeichenketten.

Beispiel:

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

Eingabe: Array von Zeichenfolgen
Ausgabe: Array von Zeichenfolgen

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

Nimmt Eingaben $aals Array von intEgern auf. Durchschleift sie mit $a|%{...}. Bei jeder Iteration wird der -format-Operator mit dem optionalen Alignment Component(basierend auf $a.count) verwendet, um die entsprechende Anzahl von Leerzeichen nach links zu füllen . Diese resultierende Zeichenfolge verbleibt in der Pipeline. Am Ende der Programmausführung verbleiben die resultierenden Zeichenfolgen als Array in der Pipeline.

Beispiele

Die Ausgabe wird bei jedem Durchlauf durch Zeilenumbrüche getrennt, da dies der Standardwert Write-Outputbei Programmabschluss für ein Array ist.

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)

Nimmt die Argumente als Liste von Zeichenfolgen und gibt auch eine Liste von Zeichenfolgen zurück.

Erläuterung:

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 dank @Ton Hospel

25 Byte Code + -aFlag.

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

Laufen mit:

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

(In einigen älteren Versionen von Perl müssen Sie möglicherweise hinzufügen -n)

Bash, 14

printf %$#d $@

Eingabeliste in der Befehlszeile.

Hier gibt es nicht viel zu erklären. Verwendet einfach integrierte Funktionen printf, um die erforderliche Polsterung basierend auf der Anzahl der übergebenen Argumente durchzuführen:

• $# ist die Anzahl der übergebenen Argumente
• %<n>d ist ein printf-Formatbezeichner, der eine Ganzzahl mit bis zu n führenden Leerzeichen ausgibt
• $@ ist die Liste aller übergebenen Argumente
• Der Formatbezeichner wird für jedes Mitglied von wiederverwendet $@.

Ideone .

Vim, 19 Bytes

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

Nimmt eine Liste von Zahlen pro Zeile auf. Verlässt sich auf :set expandtab, was beliebt ist, aber nicht universell.

Sie möchten :rightdies eindeutig verwenden . Die Frage ist, wie die Anzahl der Zeilen in die Befehlszeile eingegeben werden kann. Der traditionelle Weg ist :%ri<C-R>=line('$'), aber der ganze Text ist lang.

Der kürzere, unternehmerischere Ansatz besteht darin, die Befehlszeile mit dem !Befehl für den normalen Modus zu bilden . Es beinhaltet einige seltsame Problemumgehungen, die die Datei um 2 Zeilen erweitern und dann wieder entfernen, aber es kommt 2 Bytes kürzer heraus. Und ich bin ein bisschen schockiert, dass die verstümmelte Befehlszeile, die ich bekomme (wie :%ri+4!), tatsächlich funktioniert, aber es funktioniert.

Ruby, 40 36 34 Bytes

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

Kann weiter bearbeitet werden.

Rufen Sie als Lambda.

Erläuterung:

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

Gelee , 7 6 Bytes

L⁶xaUU

Die Eingabe ist ein Array von Zeichenfolgen. Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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@#&

Sowohl Eingabe als auch Ausgabe sind Listen von Zeichenfolgen.

Erläuterung

Length@#

Liefert die Länge der Eingabe (Anzahl der Elemente).

#~StringPadLeft~...

Pad beließ jedes Element in der Eingabe, sodass seine Länge mit der Länge der Eingabe übereinstimmt.

JavaScript (ES6), 47

Anonyme Funktion, Eingabe: Array von Zeichenfolgen, Ausgabe: Array von Zeichenfolgen
Verwenden einer rekursiven Auffüllfunktion

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

Für ein Integer / String-Array als Eingabe 49 Bytes:

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

Prüfung

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

Frühere Version 59 Bytes

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

J, 4 Bytes

":~#

Probieren Sie es online!

Unäre Funktion, die die Liste der Zahlen rechts als Array verwendet und die aufgefüllte Zeichenfolge zurückgibt.

Hier wird es auf der REPL eingesetzt. Beachten Sie, dass die Eingabezeilen um drei Leerzeichen eingerückt sind.

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

Probieren Sie es online! (Als Testsuite.)

Erläuterung

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

Golf gespielt:

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

Das ist eine Funktion von einer Liste von Zeichenfolgen zu einer Liste von Zeichenfolgen, wie die JavaScript-Antworten. replicateermöglicht es einem, eine Liste (Haskell-Zeichenfolgen sind Listen von Zeichen) einer bestimmten Größe abzurufen, sodass ich sie - und die fettgedruckte Annahme im Problem - verwende, um die Auffüllung (ihre Länge ist N- <Länge des Elements>) für jedes Element zu generieren der Eingabeliste). Ich hätte es vorgezogen, eine printfbasierte Lösung zu verwenden, anstatt diese zu verwenden replicate(zum einen wäre sie kürzer gewesen), aber die import-Anweisung macht alle Einsparungen zunichte, die an der Funktion selbst vorgenommen wurden.

Java, 83 82 Bytes

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

Erstellt eine Formatzeichenfolge, mit der die angegebenen Argumente mit einer Anzahl von Leerzeichen aufgefüllt werden, die der Länge des Arrays entspricht. Die Formatzeichenfolge wird als Argument für verwendetString.format und das Ergebnis wird dann zurückgegeben. Die Funktionsschnittstelle kann entweder ein String[]oder ein Integer[]oder ähnliches annehmen .

Volle Klasse:

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

Probieren Sie es auf Ideone.

-1 Byte dank @KevinCruijssen.

Groovy, 36 Bytes

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

Nimmt nur ein Array von Strings auf, gibt ein Array von aufgefüllten Strings aus.

MATL, 14 Bytes

'%%%dd'inYDGYD

Probieren Sie es bei MATL Online aus

Bei dieser Methode wird eine formatierte Zeichenfolge erstellt, indem zunächst die Formatzeichenfolge erstellt wird. %(NUM)dAnschließend wird die Zeichenfolgenformatierung mithilfe dieser Formatzeichenfolge und der Eingabe erneut angewendet.

JavaScript 33 Bytes

ähnlich wie @Hedi - aber die Standardauffüllung ist '', daher sind es 4 Zeichen weniger

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

Lösung:

,/(-#x)$$x:

Probieren Sie es online!

Erläuterung:

Von rechts nach links interpretiert. In Zeichenfolge konvertieren und mit der Länge der Liste links auffüllen und dann reduzieren:

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

Unkomplizierte Antwort mit eingebauter Polsterung.

sm.[;lQ

Test Suite .

C #, 39 Bytes

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

Nimmt ein List<string>und gibt ein aus List<string>.

Erläuterung:

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

Wäre die Verwendung von LINQ um einige Bytes kürzer gewesen, wenn der Import nicht gezählt worden wäre und dann IEnumerable<string>anstelle einer vollständigen Liste zurückgegeben worden wäre:

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

Liest Eingaben von stdin und verwendet C-Formatierung mit sprintf. Es sollte eine Möglichkeit geben, dass die catFunktion nicht benötigt wird, aber keine Möglichkeit finden kann, die Anführungszeichen für jedes Element ohne sie zu unterdrücken. Wenn wir nur Start- und Endanführungszeichen wünschen, können wir die etwas längere Option verwenden:

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