Étant donné une liste d' Nentiers non négatifs, sortez ces nombres avec chacun des espaces remplis à gauche par une longueur de N. (Vous pouvez également renvoyer une liste de caractères / chaînes.) Vous pouvez supposer qu'elle Nest supérieure ou égale au nombre de chiffres du plus grand nombre de la liste. Les espaces de fin sont autorisés dans la sortie.

Vous pouvez également prendre une chaîne contenant ces nombres, mais ce Nn'est pas la longueur de la chaîne, mais plutôt le nombre d'éléments dans la liste; vous pouvez également prendre une liste de chaînes, par exemple ["1", "2", "3"].

Il s'agit d'un code-golf, donc le programme le plus court en octets l'emporte.

Cas de 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 octets

Code:

Dgj

Explication:

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

Essayez-le en ligne! ou Vérifiez tous les cas de test .

Python, 32 octets

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

Une fonction anonyme qui prend un tuple en entrée. Les nombres ou les chaînes fonctionnent.

Exemple:

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 octets

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

Entrée: tableau de chaînes
Sortie: tableau de chaînes

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 octets

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

Prend l'entrée $acomme un tableau d' integers. Boucle à travers eux avec $a|%{...}. Chaque itération utilise l' -fopérateur ormat avec l'option Alignment Component(basée sur $a.count) pour remplir à gauche le nombre approprié d'espaces. Cette chaîne résultante est laissée sur le pipeline. À la fin de l'exécution du programme, les chaînes résultantes sont toutes laissées sur le pipeline sous forme de tableau.

Exemples

La sortie est séparée par des sauts de ligne à chaque exécution, car c'est la valeur par défaut Write-Outputà la fin du programme pour un tableau.

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 octets

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

Prend les arguments comme une liste de chaînes et renvoie également une liste de chaînes.

Explication:

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 octets

-4 octets grâce à @Ton Hospel

25 octets de code + -aindicateur.

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

Courir avec :

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

(Sur certaines anciennes versions de Perl, vous devrez peut-être ajouter -n)

Bash, 14

printf %$#d $@

Liste d'entrée donnée sur la ligne de commande.

Pas grand chose à expliquer ici. Utilise simplement les fonctionnalités intégrées printfpour effectuer le remplissage nécessaire, en fonction du nombre d'arguments passés:

• $# est le nombre d'arguments passés
• %<n>d est un spécificateur de format printf qui imprime un entier avec jusqu'à n espaces de tête
• $@ est la liste de tous les arguments passés
• Le spécificateur de format est réutilisé pour chaque membre de $@.

Ideone .

Vim, 19 octets

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

Prend une liste de numéros un par ligne. S'appuie sur :set expandtab, qui est populaire, mais pas universel.

Vous souhaitez clairement utiliser :right pour cela. La question est de savoir comment obtenir le nombre de lignes sur la ligne de commande. La manière traditionnelle est :%ri<C-R>=line('$'), mais tout ce texte est long.

L'approche la plus courte et la plus entreprenante consiste à former la ligne de commande à l'aide de la !commande en mode normal . Cela implique des solutions de contournement étranges, en étendant le fichier de 2 lignes puis en les supprimant à nouveau, mais il sort 2 octets plus court. Et je suis un peu choqué que la ligne de commande brouillée que je reçois (comme :%ri+4!) fonctionne réellement, mais c'est le cas.

Rubis, 40 36 34 octets

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

Peut être travaillé sur plus.

Appelez en tant que lambda.

Explication:

->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ée , 7 6 octets

L⁶xaUU

L'entrée est un tableau de chaînes. Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça fonctionne

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 octets

#~StringPadLeft~Length@#&

L'entrée et la sortie sont des listes de chaînes.

Explication

Length@#

Obtenez la longueur de l'entrée (nombre d'élément).

#~StringPadLeft~...

Pad a laissé chaque élément dans l'entrée de sorte que leurs longueurs correspondent à la longueur de l'entrée.

JavaScript (ES6), 47

Fonction anonyme, entrée: tableau de chaînes, sortie: tableau de chaînes
Utilisation d'une fonction de remplissage récursive

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

Pour un tableau entier / chaîne en entrée, 49 octets:

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

Tester

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 octets

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

Pevious Version 59 octets

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

J, 4 octets

":~#

Essayez-le en ligne!

Fonction unaire prenant la liste des nombres à droite sous forme de tableau et renvoyant la chaîne complétée.

Ici, il est utilisé au REPL. Notez que les lignes d'entrée sont en retrait de trois espaces.

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

CJam , 11 octets

lS%_,f{Se[}

Essayez-le en ligne! (En tant que suite de tests.)

Explication

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 octets

Golfé:

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

Non golfé:

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

Haskell, 47 octets

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

C'est une fonction d'une liste de chaînes à une liste de chaînes, comme les réponses JavaScript. replicatepermet d'obtenir une liste (les chaînes Haskell sont des listes de caractères) d'une taille donnée, donc je l'utilise - et l'hypothèse en gras dans le problème - pour générer le remplissage (sa longueur est N- <longueur de l'élément>, pour chaque élément de la liste de saisie). J'aurais préféré utiliser une printfsolution basée plutôt que celle-ci avec replicate(elle aurait été plus courte, pour une chose) mais l'instruction d'importation tue toutes les économies réalisées sur la fonction elle-même.

Java, 83 82 octets

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

Construit une chaîne de format conçue pour remplir les arguments donnés par un nombre d'espaces égal à la longueur du tableau. La chaîne de format est utilisée comme argument pour String.format, et le résultat est ensuite renvoyé. L'interface fonctionnelle peut accepter un String[]ou un Integer[]ou similaire.

Classe complète:

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

Essayez-le sur Ideone.

-1 octet grâce à @KevinCruijssen.

Groovy, 36 octets

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

Prend uniquement un tableau de chaînes, génère un tableau de chaînes rembourrées.

MATL, 14 octets

'%%%dd'inYDGYD

Essayez-le à MATL Online

Cela utilise la création de chaîne formatée en construisant d'abord la %(NUM)dchaîne de formatage, puis applique à nouveau le formatage de chaîne en utilisant cette chaîne de formatage et l'entrée.

JavaScript 33 octets

similaire à @Hedi - mais le remplissage par défaut est '', donc ses 4 caractères de moins

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 octets

Solution:

,/(-#x)$$x:

Essayez-le en ligne!

Explication:

Interprétée de droite à gauche. Convertissez en chaîne, et appuyez sur la touche gauche avec la longueur de la liste, puis aplatissez:

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

Réponse simple en utilisant le rembourrage intégré.

sm.[;lQ

Suite de tests .

C #, 39 octets

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

Prend a List<string>et sort a List<string>.

Explication:

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

Aurait été plus court de quelques octets pour utiliser LINQ si l'importation n'est pas comptée, puis retourner IEnumerable<string> au lieu d'une liste complète:

C #, 35 + 18 = 53 octets

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

R, 47 octets

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

Lit l'entrée de stdin et utilise le formatage de style C avec sprintf. Il devrait y avoir un moyen pour que la catfonction ne soit pas nécessaire mais n'a pas pu trouver un moyen de supprimer les guillemets sur chaque élément sans lui. Si nous voulons seulement des guillemets de début et de fin, nous pourrions utiliser l'option légèrement plus longue:

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