Étant donné un tableau d’entiers positifs en base 10, où n > 0, sortent leur représentation d’un mur binaire.

Comment cela marche-t-il?

1. Convertissez chaque nombre en sa représentation binaire.
2. Complétez la représentation avec les zéros au début du plus long, c'est 1, 2-à- dire -> 1, 10-> 01, 10.
3. Créer un mur où les 1s sont des briques et 0s sont des briques manquantes.

Un mur est un bloc de caractères où tout caractère imprimable représente une brique et un espace ( 32) représente une brique manquante. Vous pouvez choisir n’importe quel personnage pour la brique, elle n’a pas besoin d’être distincte sur le mur tant qu’il ne s’agit pas d’un espace. Le caractère de brique manquant doit être un espace. Pour l'exemple ci-dessous, j'ai utilisé *pour les briques.

Exemple

Contribution:

[ 15, 7, 13, 11 ]

1. [ 1111, 111, 1101, 1011 ]
2. [ 1111, 0111, 1101, 1011 ]

3. Sortie:

   ****
    ***
   ** *
   * **
   

Règles

• Les entrées doivent être prises en base 10, si votre langue accepte d'autres bases, vous ne pouvez pas les utiliser.
• Les nouvelles lignes de début et de fin sont autorisées.
• Les entrées peuvent être considérées comme une liste d’entiers, d’arguments séparés ou n’importe quel format raisonnable.
• La sortie peut être dans n'importe quel format raisonnable: chaîne séparée par une nouvelle ligne, tableau de lignes, tableau 2d, etc.
• Les failles standard sont interdites.

Cas de test

Notez que dans le premier cas de test, toutes les couches ont une brique vide à la fin.

[ 14, 4, 6, 2 ]

*** 
 *  
 ** 
  * 

[ 1, 2, 4, 8, 16 ]

    *
   * 
  *  
 *   
*

[ 15, 11, 15, 15 ]

****
* **
****
****

[ 11, 10, 9, 8 ]

* **
* * 
*  *
*   

C'est le code de golf si le code le plus court gagne!

MATL , 5 octets

B42*c

Essayez-le en ligne!

Explication

B     % Implicitly input an array of numbers. Convert to binary. 
      % Gives a matrix with each row corresponding to a number
42    % Push 42 (ASCII code of '*')
*     % Multiply
c     % Convert to char. Char 0 is displayed as space. Implicitly display

J , 8 octets

' *'{~#:

Essayez-le en ligne!

Explication

' *'{~#:  Input: array of integers
      #:  Convert each to binary with left-padding
' *'{~    Use the digits to index into the string ' *'

Gelée , 9 octets

Bo⁶Uz⁶ZUY

Essayez-le en ligne!

EDIT: COMMENT J BEAT JELLY DAT IMPOSSIBLE> _ <

Octave, 22 octets

@(x)[dec2bin(x)-16,'']

Essayez-le en ligne

Explication:

Sauvé quelques octets grâce à Luis Mendo! De plus, je n'ai pas remarqué que je pouvais choisir le personnage avec lequel construire le mur, pas seulement *.

@(x)                    % Take the input as a column vector
    dec2bin(x)          % Convert each row of the input to a string with 1 and 0
                        % It gets automatically padded with zeros, to fit the longest number
    dec2bin(x)-16       % Subtract 16, to get from the ASCII-values of 1/0 (48/49)
                        % to 32/33 (space and !)
@(x)[dec2bin(x)-16,'']  % Concatenate with the empty string to convert it to a string.

Ou avec de2bi:

Explication:

@(x)                          % Take the input as a column vector
               de2bi(x)       % Convert each row of the input to a binary number.
                              % Gets automatically padded to fit the longest number
            42*de2bi(x)       % Multiply the matrix by 42, which is the ASCII-value for *
           [42*de2bi(x),'']   % Concatenate the matrix with the empty string to convert
                              % it to a string. 0 are automatically displayed as spaces
@(x)fliplr([42*de2bi(x),''])

Ce qui suit fonctionne sur TIO, pour 7 octets de plus:

@(x)fliplr([42*(dec2bin(x)>48),''])

Essayez-le ici

Python 3 , 88 84 71 74 72 octets

Un lambda qui renvoie une liste de chaînes, représentant chaque ligne.

lambda n:[bin(x)[2:].replace(*'0 ').rjust(len(bin(max(n)))-2)for x in n]

Essayez-le en ligne! (lien vers la version séparée par une nouvelle ligne)

Explication

• lambda n:- Crée un lambda (anonyme), avec un paramètre n. Retourne implicitement.

• [...] - Crée une compréhension de liste.

• bin(x)[2:] - Obtient les représentations binaires des nombres.

• .replace(*'0 ')- Remplace toutes les occurrences de 0par un espace.

• .rjust(len(bin(max(n)))-2) - Pad les représentations binaires à la longueur de la plus longue.

• for x in n- Itère à travers n, avec la variable x.

Changelog

• - 1 - 3 octets grâce à @Rod, -(...)+2= 2-(...), utilisation derjust()

• Ajout d'une version avec à la bin()place, qui était invalide car elle ne fonctionnait pas pour 1et 2.

• Correction du bug ci-dessus en utilisant format().

• Changement du type de retour en liste de chaînes, car il était autorisé par l'OP.

• Correction d' un autre bogue à l' aide rjust()et la commutation de retour à bin(), repéré et fixé par @Rod.

JavaScript (ES6), 81 à 79 octets

Sauvegardé 2 octets en utilisant des nombres au lieu de caractères pour les briques, comme suggéré par Rick Hitchcock

Retourne un tableau 2D avec 1 pour les briques.

f=(a,b=[],x=1)=>a.every(n=>n<x)?a.map(n=>b.map(i=>n&i?1:' ')):f(a,[x,...b],x*2)

Cas de test

f=(a,b=[],x=1)=>a.every(n=>n<x)?a.map(n=>b.map(i=>n&i?1:' ')):f(a,[x,...b],x*2)

format = a => a.map(s => s.join``).join`\n`

console.log(format(f([ 14, 4, 6, 2 ])))
console.log(format(f([ 1, 2, 4, 8, 16 ])))
console.log(format(f([ 15, 11, 15, 15 ])))
console.log(format(f([ 11, 10, 9, 8 ])))

Haskell , 76 75 74 octets

f x|all(<1)x=x>>[""]|a<-f$map(`div`2)x=zipWith(++)a$map(cycle[" ","*"]!!)x

Essayez-le en ligne!

05AB1E , 9 octets

bí.Bí»0ð‡

Essayez-le en ligne!

Ruby, 63 59 octets

-4 octets avec l'aide d'Alexis Andersen

->*n{puts n.map{|i|("%#{('%b'%n.max).size}b"%i).tr'0',' '}}

Essayez-le en ligne!

R , 87 88 octets

Blocs de mur représentés par un 8, parce que, bien beaucoup de huit.

write(ifelse((I=sapply(scan(),intToBits))[(M=max(which(I>0,T)[,1])):1,],8,' '),1,M,,'')

Essayez-le en ligne!

La liste d'entiers en entrée est convertie en un tableau de bits qui sont supprimés des bits de fin 0 et inversés.

Le tableau réduit est ensuite généré en utilisant writeune largeur de colonne qui a été déterminée lors de la suppression du tableau.

ifelse() est la seule option SI qui fonctionne malheureusement sur les vecteurs.

Python 2 , 77 octets

lambda k:[[' *'[i&2**y>0]for y in range(len(bin(max(k)))-3,-1,-1)]for i in k]

Essayez-le en ligne!

APL (Dyalog) , 30 22 20 14 octets

6 octets sauvés grâce à @ Adám

' *'[⍉2⊥⍣¯1⊢⎕]

Essayez-le en ligne!

(suppose ⎕IO←0 qu'il s'agit par défaut sur de nombreuses machines)

Cela prend l’entrée sous forme de tableau et retourne une matrice avec * s et s.

Explication

2⊥⍣¯1⊢⎕       Convert input to binary (returns a transposed matrix of 1s and 0s)
⍉              Transpose
' *'[ ... ]    Index into this string

T-SQL, 290 octets

declare @ int;select @=max(log(a,2))+1from @i;with t as(select convert(varchar(max),a%2)b,a/2c,@-1m,ROW_NUMBER()over(order by(select 1))r from @i union all select convert(varchar(max),concat(c%2,b))b,c/2c,m-1,r from t where m>0)select replace(b,0,' ')from t where m=0group by r,b order by r

Les usages 1 de la brique, en supposant que les données proviennent du tableau@

Ungolfed, avec une explication

-- assume input is presented in an input table
declare @input table (a int)
insert into @input values (15), (7), (13), (11)

---- start here

-- figure out how many characters are needed, by taking log2
declare @max int
select @max = max(log(a, 2)) + 1
from @input

-- recursive cte
-- will join against itself, recursively finding each digit in the binary string
;with cte as
(
    select 
        convert(varchar(max), a % 2) as b, -- is the least significant bit 1 or 0
        a / 2 as c, -- remove least significant bit, for the next run
        @max - 1 as max, -- keep track of iterations left
        ROW_NUMBER() over (order by (select 1)) as rn -- keep the order of the input
    from @input

    union all -- recursive loop
              -- below columns follow the same pattern

    select convert(varchar(max), 
        concat(cte.c % 2, cte.b)) as b, -- prepend the current binary string with the newest least significant bit
        cte.c / 2 as c, 
        cte.max - 1, 
        cte.rn
    from cte
    where cte.max > 0
)
select replace(b, 0, ' ') -- swap 0s for space
from cte
where max = 0 -- only take the last iteration
group by rn, b -- grab each unique input, 
               -- need to group by row number so it can be ordered by
               -- need to group by binary string, so it can be selected
order by rn -- sort by the order the input arrived in

Mathematica, 40 octets

Grid@PadLeft@IntegerDigits[#,2]/. 0->""&

Les briques sont des 1

Mathematica, 48 octets

Grid@PadLeft@IntegerDigits[#,2]/.{0->"",1->"#"}& 

Les briques sont #

C # (.NET Core) , 112 + 18 = 130 86 + 41 = 127 octets

a=>a.Select(n=>C.ToString(n,2).Replace("0"," ").PadLeft(C.ToString(a.Max(),2).Length))

Essayez-le en ligne!

Le nombre d'octets comprend 41 octets de using System.Linq;using C=System.Convert;. Utilise 1comme personnage pour le mur. Néanmoins, c'est beaucoup trop long, même pour C # ...

Retina , 63 octets

.+
$*#<
+`(#+)\1
$1 
 #
#
{T`<`_`^(<.+(¶|$))+$
m`^<
 <
(.)<
<$1

Essayez-le en ligne! Explication:

.+
$*#<

Convertir en unaire et suffixe a <.

+`(#+)\1
$1 
 #
#

Convertir en binaire.

{T`<`_`^(<.+(¶|$))+$

Une fois que tous les <s ont atteint la gauche, supprimez-les tous.

m`^<
 <

Insérer un espace avant tout <s ayant déjà atteint la gauche.

(.)<
<$1

Déplacez tous les <s à gauche d'un pas. Rincer et répéter.

PowerShell , 100 octets

$args|%{if(($c=($a=[convert]::ToString($_,2)).length)-gt$l){$l=$c}$a-replace0,' '}|%{$_.padleft($l)}

Essayez-le en ligne!

Ugh, convertpasser au binaire dans PowerShell est tellement douloureux. Plus .lengthy appelle -replaceles 0espaces avec, plus une longue.padLeft() appel à les faire tout de même .length, tout ajoute à une longue présentation.

Les suggestions de golf pour obtenir au-dessous de 100 sont les bienvenues.

PHP, 84 octets

while(++$i<$argc)echo strtr(sprintf("\n%".-~log(max($argv),2).b,$argv[$i]),10,"* ");

Heureusement, l'opération de bit envoie le logrésultat à int. float ne fonctionnerait pas ici.

Essayez-le en ligne .

Clojure, 185 octets

(fn[i](let[b(map #(Long/toBinaryString %)i)](map #(clojure.string/replace(clojure.string/replace(format(str"%0"(reduce(fn[l i](max l(count i)))0 b)"d")(read-string %))"1""#")"0"" ")b)))

Version non-golfée:

(fn [i]
    (let [b (map #(Long/toBinaryString %) i)]
        (map
            #(clojure.string/replace
                (clojure.string/replace
                    (format
                        (str "%0"
                            (reduce
                                (fn [l i] (max l(count i))) 0 b)
                            "d")
                        (read-string %))
                        "1"
                        "#")
                "0"
                " ")
        b)))

Fonction anonyme qui prend l'argument sous forme de liste. Renvoie les lignes sous forme de liste.

En lisant les autres réponses, je parie que cela pourrait être plus petit. clojure.string/replaceprend une quantité obscène de caractères pour écrire ..

Japt , 33 30 octets

¡'0p(¡X¤lÃn o)-X¤l)+X¤)£" *"gX

Essayez-le en ligne!

3 octets sauvés grâce à @Justin Mariner

Explication

¡                              // map input integers
    (¡X¤lÃn o)                 // longest binary string length
              -X¤l)            // minus current binary string length
 '0p                           // repeat zero
                   +X¤)        // concat with current binary string
                       £       // map chars of binary string
                        " *"gX // swap 0 and 1 with ' ' and '*'

Python 3 , 92 90 octets

lambda a:[' '*(len(bin(max(a)))-len(i)-2)+i for i in[bin(i)[2:].replace(*'0 ')for i in a]]

Essayez-le en ligne!

Retourne une liste de lignes. Les empiler indique qu'ils s'alignent bien.

['111 ', ' 1  ', ' 11 ', '  1 ']
>>>
 111 
  1  
  11 
   1 

La panne

Convertit essentiellement le tableau en binaire, puis remplace tous les 0 par des espaces. Nnombre d'espaces sont ajoutés à l'avant de chaque ligne oùN = [length of longest line] - [length of line] .

-1 bytes Merci à M. Xoder

Essayez-le en ligne!

Japt , 11 octets

m¤z3 z ·r0S

Essayez-le en ligne!

Explication

m¤z3 z ·r0S  Implicit input of array
m¤           Map the array to binary strings
  z3 z       Rotate right 270° and then right 90°. This adds left padding to each string
       ·r0S  Join with newlines and replace 0s with spaces

Java 7, 130 108 88 octets

22 sauvés grâce à @TheLethalCoder 20 sauvés grâce à @Xanderhall

void a(int[]b){for(int i:b)System.out.println(Long.toBinaryString(i).replace('0',' '));}

Ungolfed:

void a(int[]b){
    for(int i:b)
        System.out.println(Long.toBinaryString(i).replace('0', ' '));       
}

Python 2, 217 octets

Après 2 heures de codage, j’ai décidé que ce n’était pas une bonne idée pour numpy

import numpy as n
i=n.loadtxt("i")
o=[n.copy(i)]
o[0].fill(10)
while n.count_nonzero(i)>0:
 o.append(i%2+32)
 i=n.vectorize(lambda x:x//2)(i)
print n.fliplr(n.array(o).T).astype('uint8').view('c').tostring().decode()

Utilisation dans Ubuntu

Installer numpy

python2 -m pip install numpy

Créer un fichier nommé iavec une entrée au format14 4 6 2

Courir

python2 prog.py

8ème , 232 254 250 octets

Code

0 >r a:new swap ( nip 2 base drop >s decimal s:len r> n:max >r a:push ) a:each drop a:new swap ( nip '0 G:c# r@ G:#> s:fmt a:push ) a:each drop rdrop a:new swap ( nip /0/ " " s:replace! a:push ) a:each drop ( nip /1/ "*" s:replace! . cr ) a:each drop

Version non-golfée avec commentaires

\ convert to binary and save longest string length
: f 0 >r a:new swap ( nip 2 base drop >s decimal s:len r> n:max >r a:push ) a:each drop ;

\ pad binary number with zero
: f1 a:new swap ( nip '0 G:c# r@ G:#> s:fmt a:push ) a:each drop rdrop ;

\ replace every 0 with space
: f2 a:new swap ( nip /0/ " " s:replace! a:push ) a:each drop ;

\ replace every 1 with * and print each line of bricks
: f3 ( nip /1/ "*" s:replace! . cr ) a:each drop ;

Ces mots doivent être appelés en séquence (voir exemple)

Usage et exemples

ok> [15,7,13,11] 0 >r a:new swap ( nip 2 base drop >s decimal s:len r> n:max >r a:push ) a:each drop a:new swap ( nip '0 G:c# r@ G:#> s:fmt a:push ) a:each drop rdrop a:new swap ( nip /0/ " " s:replace! a:push ) a:each drop ( nip /1/ "*" s:replace! . cr ) a:each drop
****
 ***
** *
* **

Ou plus clairement

ok> [15,11,15,15] f f1 f2 f3
****
* **
****
****

Pyth, 16 octets

j_MC.tm_X.Bd\0\ 

Essayez ici. Attention à l'espace de fuite.

Excel VBA, ₁₇₀ 161 octets

Golfé

Fonction de fenêtre immédiate VBE anonyme qui prend en entrée le format 1 2 3 .. nde la plage [A1]et transmet le mur binaire correspondant à la fenêtre VBE Immediate via la plage[B1,C1,2:2]

n=Split([A1]):[A2].Resize(1,UBound(n)+1)=n:[C1]="=Int(1+Log(B1,2))":For Each i In n:[B1]=i:?Replace(Replace([Right(Rept(0,C1)&Dec2Bin(B1),C1)],1,"*"),0," "):Next

Formaté:

n=Split([A1])
[A2].Resize(1,UBound(n)+1)=n
[C1]="=Int(1+Log(B1,2))"
For Each i In n
[B1]=i
?Replace(Replace([Right(Rept(0,C1)&Dec2Bin(B1),C1)],1,"*"),0," ")
Next

Ungolfed

SubRoutine complète qui prend en entrée le format Array(1, 2, 3...)et sort la paroi binaire correspondante dans la fenêtre VBE Immediate via la plage[A1,B1,2:2]

Sub a(ByRef n As Variant)
    Let Range("A1").Resize(1,UBound(n)+1) = n
    Let Range("C1").Value = "=Int(1+Log(A1,2))"
    Dim i As Integer
    For Each i In n
        Let Range("A1").Value = i
        Debug.Print Replace(
                            Replace(
                                    [Right( Rept( 0, C1) & Dec2Bin( B1), C1)],
                                    1,
                                    "*"
                            ),
                            0,
                            " "
                    )
    Next
End Sub

Charbon de bois , 20 octets

ＷＳ«⸿≔ＩιιＷι«←§ *ι≧÷²ι

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Fonctionne en convertissant manuellement chaque numéro d'entrée en fichier binaire, mais en l'imprimant dans un ordre allant de droite à gauche. Je prends l’entrée comme une chaîne terminée par une nouvelle ligne, car Charcoal n’a pas un bon moyen de saisir des listes, sinon j’écrirais quelque chose comme ceci qui malheureusement prend actuellement 21 octets:

ＷＳ⊞υＩιＷ⌈υ«Ｅυ﹪κ²↓⸿≧÷²υ

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Cette version est vectorisée sur le tableau en entrée, bien que sa sortie soit codée en dur en -s, ce qui enregistre un octet.