Étant donné tout entier non signé de 16 bits, convertissez sa forme décimale (c.-à-d. Base-10) en une grille ASCII 4x4 de ses bits, avec le bit le plus significatif (MSB) en haut à gauche, le bit le moins significatif (LSB) à en bas à droite, lire en travers puis en bas (comme le texte anglais).

Exemples

Entrée: 4242

+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| # |   |   | # |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+

Entrée: 33825

+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+

Exigences particulières

1. L'entrée doit être décimale (base-10), mais vous pouvez convertir en binaire comme vous le souhaitez (y compris en utilisant les langages intégrés, si disponibles).

2. Le format du tableau de sortie doit correspondre exactement . Cela signifie que vous devez utiliser les caractères ASCII spécifique ( -, +et |) pour les lignes de la grille de table comme le montre, l' intérieur de chaque cellule est de 3 caractères et vrais bits sont représentés par #tout faux est représenté par un espace ( ).

3. Les espaces blancs avant ou arrière ne sont pas autorisés. Une nouvelle ligne finale est requise .

4. L'ordre des bits doit correspondre aux exemples décrits.

Indemnités

1. L' entrée doit être un numéro de base 10 sur la ligne de commande, l' entrée standard, ou l' entrée d'utilisateur, mais ne doit pas être codé en dur dans votre code source.

Que le code le plus court le plus clair gagne! :-)

J, 26 octets

('   ';' # '){~4 4$_16{.#:

Un verbe anonyme. Heureusement, J est très bon pour dessiner des boîtes. Essayons-le:

   f =. ('   ';' # '){~4 4$_16{.#:
   f 4242
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| # |   |   | # |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+

Comme certains commentateurs l'ont mentionné, la façon dont J dessine les boîtes dépend du système: sur certaines plates-formes, ce code fonctionnera avec les paramètres par défaut, mais sur d'autres, les boîtes seront dessinées en utilisant des caractères de dessin au trait Unicode. (Les commandes 9!:6et9!:7 vous permettent d'interroger et de définir les caractères pour dessiner des valeurs encadrées avec, respectivement.)

JavaScript (ES6), 102

... ou 96 en utilisant returnau lieu de console.log.

Testez l'exécution de l'extrait ci-dessous dans un navigateur compatible EcmaScript 6.

f=n=>{for(o=h=`
+---+---+---+---+
`,z=16;z--;n/=2)o=(z&3?'':h+'|')+` ${' #'[n&1]} |`+o;console.log(o)}

// TEST
console.log=x=>O.innerHTML=x+O.innerHTML

function test(n) { f(n); console.log(n); }

<input id=I value=4680><button onclick='test(+I.value)'>-></button>
<pre id=O></pre>

Befunge -93, 196 218 octets

&00p12*v>>4>"---+",v v <
v*:*:*:<   | :-1,,,< #
>:*2/10p^  >"+",25*,10g|
     > #v^#         $< @
 25*,^  >4" |",,v ,*<>
v>"#",00g10g-00p 10g
 |`-1g01g00     <>48^
v>" ",10g
>2/10p>"| ",,1-:#^_$>^

Pour exécuter le programme ...

1. Allez à l' interprète en ligne .
2. Collez ce code dans la grande zone de texte.
3. Cliquez Show.
4. Saisissez le numéro souhaité dans la Inputcase.
5. Cliquez Run. (Ou passez Slowà quelque chose comme 5 millisecondes, puis cliquez sur Show.)
6. Ta-da!

Sortie pour 4242:

+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| # |   |   | # |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+

Sortie pour 33825:

+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+

Explication

Oh mon Dieu, dans quoi je me suis embarqué? Eh bien, c'est parti! (Le code non pertinent est remplacé par l' .art.)

Partie 1: Obtenez l'entrée (stockez en 0,0) et calculez 32768 (stockez en 1,0).

&00p12*v>
v*:*:*:< 
>:*2/10p^

Partie 2: Imprimez "+ --- + --- + --- + ---".

>4>"---+",v
  | :-1,,,<

Partie 3: Imprimez "+" et une nouvelle ligne et vérifiez si (1,0) est 0 (c'est-à-dire que nous avons terminé). Si oui, terminez. Sinon, continuez.

 ........... v <
   | ....... # 
   >"+",25*,10g|
v.#         $< @
>4" |",,v ...

Partie 4: Obtenez des chiffres binaires d'entrée, en mettant à jour (0,0) et (1,0) au fur et à mesure. Imprimez les bonnes choses. Je profite du comportement de bouclage de Befunge.

 .....  >4" |",,v ,*<.
v>"#",00g10g-00p 10g
 |`-1g01g00     <>48^
v>" ",10g
>2/10p>"| ",,1-:#^_...

Partie 5: Imprimez une nouvelle ligne et revenez à la partie qui affiche "+ --- + --- + --- + --- +". L'astuce de bouclage est utilisée.

     > #.^.         .. .
 25*,^  ......... ...>
................ ...
 .........      .....
........
.................._$>^

Ta-da!

Julia, 156 143 octets

n->(p=println;l="+"*"---+"^4;for i=1:4 p(l,"\n| ",join([j>"0"?"#":" "for j=reshape(split(lpad(bin(n),16,0),""),4,4)[:,i]]," | ")," |")end;p(l))

Non golfé:

function f(n::Int)
    # Convert the input to binary, padded to 16 digits
    b = lpad(bin(n), 16, 0)

    # Split b into a 4x4 matrix
    m = reshape(split(b, ""), 4, 4)

    # Store the line separator for brevity
    l = "+" * "---+"^4

    # Print each column of the matrix as a row
    for i = 1:4
        println(l, "\n| ", join([j > "0" ? "#" : " " for j = m[:,i]], " | "), " |")
    end

    # Print the bottom of the table
    println(l)
end

Essayez-le en ligne

Python 2, 157 153 151 146 octets

J=''.join;R='+---'*4;i=format(input(),'016b')
print J(R+'+\n|'+J(' '+('#'if int(l)else' ')+' |'for l in i[n*4:-~n*4])+'\n'for n in range(4)),R+'+'

Merci à Morgan Thrapp pour avoir économisé 4 octets et à Jonathan Frech pour en avoir économisé 5.

Usage

$ python test.py
33825
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+

Ruby, 118 114

b="%016b"%gets
l=?++"---+"*4
1.upto(16){|i|puts l if i%4==1
print"| #{b[i-1]==?0?' ':?#} "
puts ?|if i%4<1}
puts l

merci pour @ w0lf d'avoir sauvé quelques caractères.

GNU sed + dc, 116

Le score inclut +1 pour les -rdrapeaux sed:

s/.*/dc -e2o&p/e
:
s/^.{,15}$/0&/;t
s/./| & /g
s/.{16}/\n+---+---+---+---+\n&|/g
y/01/ #/
s/\n([-+]+)(.*)/\1\2\n\1/

Sortie de test:

$ { echo 4242 ; echo 33825 ; } | sed -rf 16bitgrid.sed
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| # |   |   | # |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
$ 

Alternativement:

Pure sed, 146

Vous pourriez penser que c'est de la triche d'utiliser sedl'extension GNU pour évaluer unedc commande. Dans ce cas, nous pouvons le faire un peu différemment, selon cette méta-réponse . Bien sûr, la question indique clairement que l'entrée doit être en base 10, mais ici j'essaie de prétendre que nous pouvons remplacer cela pour les sedréponses et utiliser unaire (base 1) à la place.

:
s/11/</g
s/<([ #]*)$/< \1/
s/1/#/
y/</1/
t
:a
s/^.{,15}$/0&/;ta
s/./| & /g
s/.{16}/\n+---+---+---+---+\n&|/g
y/01/ #/
s/\n([-+]+)(.*)/\1\2\n\1/

Sortie de test

Utilisation printfpour générer la chaîne unaire nécessaire:

$ printf "%33825s" | tr ' ' 1 | sed -rf 16bitgrid.sed 
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
$ 

C ++ 11, 193 191 190 190 176 172 octets

Ma première solution sur codegolf jamais, alors ne me blâmez pas.

#include<iostream>
int n,j,i=65536;int main(){std::cin>>n;for(;j<9;){for(int k:{0,0,0,0})if(j%2)printf("| %s",n&(i/=2)?"# ":"  ");else printf("+---");puts(j++%2?"|":"+");}}

Non golfé

#include <iostream>
int n, i = 65536, j;

int main()
{
    std::cin >> n;

    for (; j < 9;)
    {
        for(int k:{0,0,0,0})
        {
            if (j % 2)
            {
                printf("| %s", n & (i /= 2) ? "# " : "  ");
            }
            else
            {
                printf("+---");
            }
        }
        puts(j++ % 2 ? "|" : "+");
    }
}

La version précédente

#include <iostream>
using namespace std;

int n, i = 65536, j;
int main()
{
    cin >> n;

    for (; j < 9;)
    {
        for(int k:{0,0,0,0})
        {
            if (j % 2)
            {
                cout << "| " << (n & (i /= 2) ? "# " : "  ");
            }
            else
            {
                cout << "+---";
            }
        }
        cout << (j++ % 2 ? "|\n" : "+\n");
    }
}

Pyth, 37 octets

Jj*3\-*5\+JVc4_m@" #".>Qd16jd.i*5\|NJ

Essayez-le en ligne: Démonstration ou suite de tests

Explication:

Jj*3\-*5\+J
  *3\-                       the string "---"
      *5\+                   the string "+++++"
 j                           join second by first string: 
                                "+---+---+---+---+"
J                            save in J
          J                  print J

Vc4_m@" #".>Qd16jd.i*5\|NJ
    m         16             map each d in [0, 1, ..., 15] to:
          .>Qd                 input number Q shifted to the right by d
     @" #"                     and take the ^th char in " #" (modulo 2)
   _                         reverse this list of chars
 c4                          split into 4 groups
V                            for each group N in ^:
                    *5\|       the string "|||||"
                  .i    N      interleave ^ with N
                jd             join chars with spaces and print
                         J     print J

CJam, 43 41 octets

'+5*'-3**N+ri2bG0e[4/{" #"f='|5*.\S*N2$}/

Certainement golfable, mais c'est un début, je suppose. Génère la ligne supérieure, puis pour chaque 4 bits, il crée une ligne paire et copie la ligne impaire précédente.

Essayez-le en ligne .

Python 2, 122 121 120 octets

n=bin(4**8+input())[3:]
i=0
exec"print'| %s |'%' | '.join(' #'[x>'0']for x in n[:4])*i or'+---'*4+'+';n=n[4*i:];i^=1;"*9

-1 octet grâce à l' 4**8+astuce soignée de @ xnor . L'impression principale se fait en bouclant 9 fois, en sélectionnant la ligne appropriée pour impair / pair.

Python 2, 94

n=input()
s=();exec"s=(' #'[n%2],)+s;n/=2;"*16
a='+---'*4+'+\n'
print(a+'| %s '*4+'|\n')*4%s+a

L'idée est de prendre le motif

+---+---+---+---+
| _ | _ | _ | _ |
+---+---+---+---+
| _ | _ | _ | _ |
+---+---+---+---+
| _ | _ | _ | _ |
+---+---+---+---+
| _ | _ | _ | _ |
+---+---+---+---+

sauf avec %sà la place des blancs et effectuez la substitution de tuple. Le tuple ressemble

('#', ' ', ' ', ' ', ' ', '#', ' ', ' ', ' ', ' ', '#', ' ', ' ', ' ', ' ', '#')

Il est créé en retirant les chiffres de l'entrée en binaire et en ajoutant le symbole correspondant à l'avant du tuple. Une expression avec un tuple explicite donne une longueur égale.

%tuple(' #'[c>'0']for c in bin(input()+4**8)[3:])

Merci à Sp3000 pour 2 octets.

PowerShell, 203 188 182 octets

param($a)$l="+---+---+---+---+";$l;$b=([int64][convert]::ToString($a,2)).ToString(@(,"0"*16)-join'');@(1..16|%{if($b[$_-1]-eq'1'){"| # "}else{"|   "};if($_%4-eq0){"|`n$l`n"}})-join''

_{Modifier - enregistré 15 octets en changeant l'ordre | est dessiné, afin que nous puissions vider le .TrimEnd("|")sur la sortie et à la place convertir la boucle for en un bloc de sous-code qui produit un tableau}

_{Edit2 - sauvé encore 6 octets en éliminant le besoin d'enregistrer dans le $o variable et juste de sortir avec -join''directement.}

Ooooooooof.

Il est difficile de dessiner dans PowerShell . Travailler avec des chiffres binaires dans PowerShell est difficile de .

Utilise des éléments intégrés à [convert]l'entier d'entrée dans une représentation sous forme de chaîne en binaire, puis rediffusés en un [int64]afin que nous puissions rappeler .ToString()afin d'ajouter / ajouter le nombre approprié de zéros. (Notez que la création d'un tableau de chaînes et leur jonction@(,"0"*16)-join'' est 1 caractère plus court que la chaîne littérale "0000000000000000")

Ensuite, prenez une simple boucle for 1..16|%{...} vérifiant chaque chiffre pour construire notre tableau de sortie, puis enfin le -join''remettre ensemble.

Précédent, 188

param($a)$l="+---+---+---+---+";$l;$b=([int64][convert]::ToString($a,2)).ToString(@(,"0"*16)-join'');$o=@(1..16|%{if($b[$_-1]-eq'1'){"| # "}else{"|   "};if($_%4-eq0){"|`n$l`n"}});$o-join''

Précédent-er, 203

param($a)$l="+---+---+---+---+`n|";$o=$l;$b=([int64][convert]::ToString($a,2)).ToString(@(,"0"*16)-join'');1..16|%{if($b[$_-1]-eq'1'){$o+=" # |"}else{$o+="   |"};if($_%4-eq0){$o+="`n$l"}};$o.TrimEnd('|')

Javascript (ES6), 216 207 octets

Définit une fonction anonyme.

i=>(","+("0".repeat(16)+i.toString(2)).slice(-16).split``.map((v,l,a)=>l%4<1?"| "+a.slice(l,l+4).map(v=>v?"#":" ").join` | `+" |":"").filter(v=>!!v).join`,`+",").replace(/,/g, `
+---+---+---+---+
`).slice(1)

Merci à ETHproductions pour des conseils!

CJam, 62 octets

"+---|   "4/{4*_c+N+}%4*_0=]sqi2bG0e[ee{~{_9*\4%5*-K+'#t0}&;}/

Essayez-le en ligne .

Pyth, 50 octets

j.i*5]<3*5"+---"ms.i*5\|dc4mj@" #"qd\1*2\ .[Z16.BQ

L'explication devra attendre une autre fois, je poste ceci sur mon téléphone!

Rubis, 102

n=gets.to_i
print j="+---"*4+"+
" 
19.downto(0){|i|print i%5>0?"| #{((n>>i*4/5)%2*3+32).chr} ":"|
"+j}

Algorithme

Imprimer un séparateur horizontal

Boucle 20 fois (19..0)

Si le numéro de boucle ne divise pas par 5, convertissez-le en un nombre compris entre 16..0 en multipliant par 4/5. Imprimer un espace (ascii 32) ou #(ascii 32 + 3 = 35) précédé de| et suivi d'un espace.

Si le numéro de boucle est divisé par 5, imprimez un |, un retour à la ligne et un séparateur horizontal identiques au premier.

Perl, 103 octets

$_=(($l='+---'x4 .'+
').'| x 'x4 .'|
')x4 .$l;@n=(sprintf'%016b',<>)=~/./g;s/x/$n[$x++]?'#':$"/eg;print

Beaucoup de répétitions de chaînes pour faire une grille de xs, convertir l'entrée en binaire puis s///le xs en #ou $"( ) selon le drapeau à la position spécifiée ( $x).

PHP, 159 octets

bingrid16.php:

<?$r=10;while(--$r){if($r%2){echo str_repeat('+---',4).'+';}else{$c=9;echo'|';while(--$c){echo' '.($c%2?'|':($argv[1]&pow(2,$r*2+$c/2-5)?'#':' '));}}echo"\n";}

Usage:

php bingrid16.php 4242

Rien d'extraordinaire, juste rendu le rendu forcé.

J'ai essayé un autre angle en utilisant des tableaux au lieu de boucles, mais il était plus long à 224 octets:

<?=implode(array_map(function($r)use($argv){return($r%2?str_repeat('+---',4).'+':'|'.implode(array_map(function($c)use($r,$argv){return' '.($c%2?'|':($argv[1]&pow(2,$r*2+$c/2-5)?'#':' '));},range(8,1))))."\n";},range(9,1)));

Perl 5 , 85 84 octets

84 83 octets de code + -pindicateur

-1 octet après que Dom m'a rappelé d'utiliser une nouvelle ligne

say$\='+'."---+"x4,"
| ",map y/01/ #/r.' | ',/./g for(sprintf"%016b",$_)=~/..../g}{

Essayez-le en ligne!

c99 263 octets

golfé:

main(int argc,char **argv){short i=atoi(argv[argc-1]);char *t="| # ", *f="|   ",*a[16],**p=a,*b="+---+---+---+---+\r\n";while(p<a+16){if((i|0x8000)==i)(*(p++))=t;else(*(p++))=f;i<<=1;}for(p=a;p<a+16;p+=4)printf("%s%s%s%s%s|\n",b,*p,p[1],p[2],p[3]);printf("%s",b);}

non golfé:

main(int argc, char **argv)
{
    short i=atoi(argv[argc -1]);
    char *t ="| # ", *f="|   ",*a[16],**p=a,*b="+---+---+---+---+\r\n";

    while (p<a+16)
    {
        if((i|32768)==i)
            (*(p++))=t;
        else
            (*(p++))=f;

        i<<=1;
    }

    for (p=a;p<a+16;p+=4)
        printf("%s%s%s%s%s|\n",b,*p,p[1],p[2],p[3]);
    printf("%s",b);
}

J'ai juste aimé présenter une variante un peu décalée et j'ai pensé que c'était la première fois que cela convenait (même cela me coûtait quelques octets, mais C ne pouvait pas relever ce défi en octets même avec une chance, donc je m'en fichais) d'utiliser l'argc / argv

Rubis, 95

Nod to Mhmd pour une conversion de chaîne concise, mais je voulais essayer d'utiliser des méthodes de chaîne au lieu de méthodes numériques.

->i{puts g='+---'*4+?+;("%016b"%i).scan(/.{4}/){puts$&.gsub(/./){"| #{$&<?1?' ':?#} "}+"|
"+g}}

Rubis, 93

Une version légèrement plus courte utilisant uniquement des opérations numériques.

->i{n=g='+---'*4+"+
";15.downto(0){|m|n+="| #{[' ',?#][1&i>>m]} "
n+="|
"+g if m%4<1}
puts n}

C # 227 octets

Golfé:

class B{public static string G(short v){string s="",b=System.Convert.ToString(v,2).PadLeft(16,'0');for(int i=9;i>0;){s+=i--%2!=0?"+---+---+---+---+\n":"| "+b[i*2+1]+" | "+b[i*2]+" | "+b[i*2-1]+" | "+b[i*2-2]+" |\n";}return s;}}

Indention:

class B
{
    public static string G(short v)
    {
        string s="",b=System.Convert.ToString(v, 2).PadLeft(16,'0');
        for(int i=9;i>0;)
            s+=i--%2!=0?"+---+---+---+---+\n":"| "+b[i*2+1]+" | "+b[i*2]+" | "+b[i*2-1]+" | "+b[i*2-2]+" |\n";
        return s;
    }
}

La première fois que j'essaie quelque chose comme ça, des conseils seraient les bienvenus!

Python 3, 145 144 octets

En ligne:

a="|";b="+"+"---+"*4+"\n";r=0,1,2,3;(lambda x:print(b+b.join(a+a.join(" %s "%'# '[x&2**(i+j*4)<1]for i in r)+a+"\n"for j in r)+b))(int(input()))

Avec les nouvelles lignes:

a="|"
b="+"+"---+"*4+"\n"
r=0,1,2,3
lambda x:print(b+b.join(a+a.join(" %s "%'# '[x&2**(i+j*4)<1]for i in r)+a+"\n"for j in r)+b)
x(int(input()))

Edit: Tanks @manatwork pour économiser 1 octet

Kotlin , 192 octets

{val v=it.toString(2).padStart(16,'0')
fun p(){(0..3).map{print("+---")}
println("+")}
(0..3).map{p()
v.subSequence(it*4,(it+1)*4).map{print("| ${if(it>'0')'#' else ' '} ")}
println("|")}
p()}

Embellie

{
    val v = it.toString(2).padStart(16, '0')
    fun p() {
        (0..3).map { print("+---") }
        println("+")
    }
    (0..3).map {
        p()
        v.subSequence(it *4, (it +1) *4).map {print("| ${if (it > '0') '#' else ' '} ")}
        println("|")
    }
    p()
}

Tester

var b:(Int) -> Unit =
{val v=it.toString(2).padStart(16,'0')
fun p(){(0..3).map{print("+---")}
println("+")}
(0..3).map{p()
v.subSequence(it*4,(it+1)*4).map{print("| ${if(it>'0')'#' else ' '} ")}
println("|")}
p()}

fun main(args: Array<String>) {
    b(255)
}

05AB1E , 45 octets

bDg16αúS4ôεεð.ø}õ.ø'|ý}õ.ø…+--3F.∞}¶.øý10„# ‡

Essayez-le en ligne!