Grille binaire 16 bits

29

É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! :-)

type_outcast
la source
1
Connexe
Sp3000
2
La première phrase me semble déroutante, où elle dit "convertir sa forme décimale ". Sur la base du reste de l'article et de l'exemple, il semble que l' entrée soit donnée sous forme décimale, mais vous devez convertir la forme binaire de la valeur en grille.
Reto Koradi
1
@RetoKoradi vous avez essentiellement raison, mais la question vous oblige à convertir un nombre décimal en une grille binaire . Il n'y a aucune obligation explicite de travailler avec un nombre binaire, seulement un détail d'implémentation probable.
type_outcast
L'écriture d'une fonction avec le nombre de base 10 comme argument de fonction compte-t-elle comme entrée utilisateur?
Alex A.
2
Puisque vous dites que le nombre donné est un "entier 16 bits non signé ", il est par définition sous forme binaire. Quand j'ai lu ceci pour la première fois, cela sonnait comme si l'entrée serait donnée sous forme binaire. Tout devient clair vers la fin. Mais au moins pour moi, le premier paragraphe ne rend pas vraiment compte du problème.
Reto Koradi du

Réponses:

21

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

Lynn
la source
Savez-vous (ou quelqu'un d'autre) s'il existe un consensus sur la commande de dessin de boîte pour la notation du golf, alors? Personnellement, je pense que l'hypothèse du code golf est que les solutions fonctionnent sur la majorité des systèmes sur lesquels le langage de la solution fonctionne, non? À quoi ressemblerait une solution qui affiche les bonnes cases sur toutes (ou presque) les installations J? Au fait, j'aime vraiment votre solution! Mon cerveau continue de progresser, c'est exactement ce que j'aime dans le golf de code.
type_outcast
5
@type_outcast Nous n'avons pas besoin de portabilité pour les défis de golf de code. Tant qu'il fonctionne avec une implémentation sur une plate-forme, il est valide.
Dennis
Merci pour la réponse @Dennis. Je suis donc content que ma présomption soit fausse, car j'aime (toujours) vraiment la solution de Mauris! :-)
type_outcast
14

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>

edc65
la source
6
Est "JavaScripy" un peu étrange mashup javascript / python? ;-)
Digital Trauma
6
@DigitalTrauma bien sûr. Mais comme le monde n'est pas prêt ( tvtropes.org/pmwiki/pmwiki.php/Main/TheWorldIsNotReady ) pour cette nouvelle évolution, je reviendrai sur JavaScript
edc65
Cool, cela fonctionne sur Edge!
Arturo Torres Sánchez
Doit ... pas ... cliquer ... tvtropes ...
RK.
14

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!

El'endia Starman
la source
10

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

Alex A.
la source
10

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
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
Zach Gates
la source
Vous pouvez enregistrer deux octets si vous tirez '+---'*4dans une variable et deux autres si vous le faitesj=''.join
Morgan Thrapp
Aucun problème! Je travaillais en fait sur une solution très similaire.
Morgan Thrapp du
@downvoter Care à expliquer?
Zach Gates
Puisque vous n'utilisez Python 3, vous pouvez remplacer int(input())avec input()et sauver cinq octets.
Jonathan Frech
9

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.

Mhmd
la source
1
Vous pouvez enregistrer quelques octets si vous écrivez des caractères littéraux en utilisant la ?notation (ex: ?|au lieu de '|'). Cela fonctionne pour tout sauf l'espace.
Cristian Lupascu
@ w0lf J'ai trouvé que cela ?\sfonctionne pour l'espace, mais ce n'est pas vraiment utile ici.
Mhmd
7

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 
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
$ 
Traumatisme numérique
la source
Joli. Cela ressemble un peu à la solution Perl que j'ai proposée comme preuve de concept (privée) tout en affinant la question.
type_outcast
@type_outcast BTW est parfaitement OK pour publier votre propre solution comme réponse :)
Digital Trauma
Je sais :-) Je n'ai pas passé beaucoup de temps à jouer au golf, car j'étais plus concentré sur la pose d'une bonne question, mais je peux encore la revisiter et la poster si je peux la jouer dans quelque chose d'au moins à mi-chemin respectable. En ce moment, je m'amuse trop à chercher les réponses de tout le monde.
type_outcast
6

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");
    }
}
Zereges
la source
Astuce: 0x10000 est 65536, ayant le préfixe '0x', hex est toujours plus long que décimal
edc65
Astuce 2: vous devriez éviter using namespace stddans le code de production. Et ce n'est pas utile ici aussi.
edc65
@ edc65 dec-> hex bonne idée, j'ai toujours pensé à hex ayant une représentation plus courte, mais oubliez 0x. using namespace stdenregistre quelques octets, car je n'ai pas à préfixer coutet cinavec std::. Même en utilisant juste using std::cout;ne va pas aider.
Zereges
Salut Zereges. Vous pouvez supprimer l'espace entre l'inclusion et la bibliothèque .. et supprimer le type de retour pour la fonction principale.
wendelbsilva
C++ne prend pas en charge auto int.
Zereges
6

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
Jakube
la source
5

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 .

Sp3000
la source
4

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.

Sp3000
la source
Je pense que cela bin(4**8+input())[3:]économise un octetformat
xnor
@xnor Oh, c'est bien :)
Sp3000
4

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.

xnor
la source
4

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('|')
AdmBorkBork
la source
1
J'espère que c'était un "fun dur". :-) +1 pour votre explication; cela a aidé ma compréhension limitée de PowerShell.
type_outcast
3

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!

adroitwhiz
la source
Bon travail! Puisque vous utilisez ES6, voici quelques conseils: 1. Chaque fois que vous devez utiliser une chaîne comme seul paramètre d'une fonction, vous pouvez utiliser une chaîne de modèle, comme ceci: .join` | `​2. Vous pouvez également utiliser des chaînes de modèle pour interpoler des valeurs: i=>`,${"0".repeat....join`,`},`.replace...3 Vous pouvez trouver plus de conseils ES6 sur ce fil .
ETHproductions
Cela semble avoir cessé de fonctionner, mais en jouant un peu plus au golf, je peux obtenir 197 avec le résultat correct:i=>`,${("0".repeat(16)+i.toString(2)).slice(-16).split``.map((v,l,a)=>l%4?"":"| "+a.slice(l,l+4).map(v=>' #'[v]).join` | `+" |").filter(v=>v).join`,`},`.replace(/,/g,`<line break>+---+---+---+---+<line break>`).slice(1)
ETHproductions
2
("0".repeat(16)+i.toString(2)).slice(-16) ->(65536|i).toString(2).slice(1)
edc65
Garder votre logique exacte, cela peut être joué à 169, voir jsfiddle.net/76fp7aw6
edc65
2

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!

Sok
la source
2

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.

Level River St
la source
2

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

Dom Hastings
la source
2

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)));
zamnuts
la source
2

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!

Xcali
la source
Belle approche bien meilleure que la mienne! Une nouvelle ligne littérale vous fera également économiser un octet supplémentaire $/!
Dom Hastings
1

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

Zaibis
la source
1

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}}
Pas que Charles
la source
1

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}
Pas que Charles
la source
1

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!

anthonytimmers
la source
Tout d'abord, je compte 286 octets et vous pouvez supprimer les espaces d'indentation.
Blue
Comment comptez-vous exactement cela? Je suis allé dans les propriétés pour voir la taille du fichier, mais je ne sais pas si c'est la façon de le faire! Sans retrait, je suis descendu à 230 octets!
anthonytimmers
Utilisez quelque chose comme mothereff.in/byte-counter , ou si vous êtes sous linux, utilisez la wccommande
Blue
1

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

Bassintag
la source
1
Sur la base de gnibbler de pointe , hardcoding r=0,1,2,3est plus courte que 1 caractère à générer avec r=range(4).
manatwork
0

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)
}
jrtapsell
la source