Konvertieren Sie bei einer beliebigen vorzeichenlosen 16-Bit-Ganzzahl die Dezimalzahl (dh die Zahl zur Basis 10) in ein 4 × 4-ASCII-Raster der Bits, wobei sich das höchstwertige Bit (MSB) oben links und das niedrigstwertige Bit (LSB) bei befindet unten rechts lesen Sie quer und dann nach unten (wie englischer Text).

Beispiele

Eingabe: 4242

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

Eingabe: 33825

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

Spezifische Anforderungen

1. Die Eingabe muss dezimal erfolgen (Basis 10). Sie können sie jedoch nach Belieben in Binärdateien konvertieren (einschließlich der Verwendung von integrierten Sprachen, falls verfügbar).

2. Das Format der Ausgabetabelle muss genau übereinstimmen . Dies bedeutet, dass Sie die angegebenen ASCII-Zeichen ( -, +und |) für die Tabellengitterlinien verwenden müssen. Das Innere jeder Zelle besteht aus 3 Zeichen, und wahre Bits werden durch dargestellt, #während false durch ein Leerzeichen ( ) dargestellt wird.

3. Führende oder nachfolgende Leerzeichen sind nicht zulässig. Letzte Zeile ist erforderlich .

4. Die Bitreihenfolge muss mit den beschriebenen Beispielen übereinstimmen.

Zulagen

1. Die Eingabe muss eine Zahl zur Basis 10 in der Befehlszeile, der Standardeingabe oder der Benutzereingabe sein, darf jedoch nicht fest in Ihrem Quellcode codiert sein.

Möge der klarste kürzeste Code gewinnen! :-)

J, 26 Bytes

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

Ein anonymes Verb. Zum Glück kann J sehr gut Boxen zeichnen. Probieren wir es aus:

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

Wie einige Kommentatoren bereits erwähnt haben, ist die Art und Weise, wie J Felder zeichnet, systemabhängig: Auf einigen Plattformen funktioniert dieser Code unter den Standardeinstellungen, auf anderen werden die Felder mit Unicode-Strichzeichen gezeichnet. (Mit den Befehlen 9!:6und9!:7 können Sie die Zeichen abfragen und festlegen, mit denen jeweils Boxwerte gezeichnet werden sollen.)

JavaScript (ES6), 102

... oder 96 returnstatt console.log.

Testen Sie das folgende Snippet in einem EcmaScript 6-kompatiblen Browser.

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 Bytes

&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-:#^_$>^

Um das Programm auszuführen ...

1. Gehen Sie zum Online-Dolmetscher .
2. Fügen Sie diesen Code in das große Textfeld ein.
3. Klicken Sie auf Show.
4. Geben Sie die gewünschte Nummer in das InputFeld ein.
5. Klicken Sie auf Run. (Oder ändern Sie Slowden Wert auf 5 Millisekunden und klicken Sie dann auf Show.)
6. Ta-da!

Ausgabe für 4242:

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

Leistung für 33825:

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

Erläuterung

Oh Gott, worauf habe ich mich eingelassen? Gut geht hier! (Irrelevanter Code wird durch .s ersetzt.)

Teil 1: Eingabe abrufen (in 0,0 speichern) und 32768 berechnen (in 1,0 speichern).

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

Teil 2: Drucken Sie "+ --- + --- + --- + ---" aus.

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

Teil 3: Gib "+" und eine neue Zeile ein und überprüfe, ob (1,0) 0 ist (dh wir sind fertig). Wenn ja, kündigen Sie. Andernfalls fahren Sie fort.

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

Teil 4: Holen Sie sich Binärzahlen der Eingabe und aktualisieren Sie dabei (0,0) und (1,0). Drucken Sie die richtigen Dinge. Ich nutze Befunges Umgriffsverhalten.

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

Teil 5: Drucken Sie eine neue Zeile und kehren Sie zu dem Teil zurück, in dem "+ --- + --- + --- + --- +" gedruckt wird. Wrap-Around-Trick wird verwendet.

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

Ta-da!

Julia, 156 143 Bytes

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

Ungolfed:

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

Probieren Sie es online aus

Python 2, 157 153 151 146 Bytes

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

Vielen Dank an Morgan Thrapp für das Speichern von 4 Bytes und an Jonathan Frech für das Speichern von 5 Bytes.

Verwendung

$ 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

danke für @ w0lf zum speichern einiger zeichen.

GNU sed + dc, 116

Punktzahl beinhaltet +1 für -rFlaggen an 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/

Testausgang:

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

Alternative:

Pure sed, 146

Man könnte meinen, es wäre ein Betrug, die sedGNU-Erweiterung zu verwenden, um einen dcBefehl auszuwerten . In diesem Fall können wir das gemäß dieser Meta-Antwort etwas anders machen . Natürlich ist die Frage eindeutig fest, dass die Eingabe muss 10 in der Basis sein, aber hier Anspruch Ich versuche , dass wir , dass für außer Kraft setzen können sedAntworten und einstellige (Basis 1) stattdessen verwenden.

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

Ausgang testen

Verwenden Sie printf, um den erforderlichen unären String zu generieren:

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

C ++ 11, 193 191 190 176 172 Bytes

Meine erste Lösung für Codegolf, also beschuldigen Sie mich nicht.

#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?"|":"+");}}

Ungolfed

#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 ? "|" : "+");
    }
}

Vorherige Version

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

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

Probieren Sie es online aus: Demo oder Test Suite

Erläuterung:

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 Bytes

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

Auf jeden Fall golffähig, aber ich denke, es ist ein Anfang. Erzeugt die oberste Zeile und erstellt dann für jeweils 4 Bits eine gerade Zeile und kopiert die vorherige ungerade Zeile.

Probieren Sie es online aus .

Python 2, 122 121 120 Bytes

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 Byte dank @ xnors ordentlichem 4**8+Trick. Der Hauptdruck erfolgt durch neunmaliges Schleifen, wobei die entsprechende Zeile für ungerade / gerade ausgewählt wird.

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

Die Idee ist, das Muster zu nehmen

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

außer mit %sanstelle von Leerzeichen und Tupelsubstitution durchführen. Das Tupel sieht aus wie

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

Es wird erstellt, indem Ziffern aus dem Eingang in binärer Form abgenommen und das entsprechende Symbol an der Vorderseite des Tupels hinzugefügt werden. Ein Ausdruck mit explizitem Tupel ergab die gleiche Länge.

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

Danke an Sp3000 für 2 Bytes.

PowerShell, 203 188 182 Bytes

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

_{Bearbeiten - spart 15 Bytes durch Ändern der Reihenfolge, |in der gezeichnet wird, damit wir .TrimEnd("|")die Ausgabe sichern und stattdessen die for-Schleife in einen Subcode-Block konvertieren können, der ein Array erzeugt}

_{Edit2 - Speichert weitere 6 Bytes, indem das Speichern in der $oVariablen entfällt und nur -join''direkt mit ausgegeben wird .}

Ooooooooof.

In PowerShell zu zeichnen ist schwierig . Das Arbeiten mit Binärziffern in PowerShell ist schwierig .

Verwendet integrierte Funktionen für [convert]die Eingabe-Ganzzahl in eine Zeichenfolgendarstellung in Binärform und wandelt sie dann wieder in eine um, [int64]damit wir .ToString()die entsprechende Anzahl von Nullen voranstellen / auffüllen können. (Beachten Sie, dass das Erstellen und Verknüpfen eines Strings-Arrays @(,"0"*16)-join''1 Zeichen kürzer ist als der Literal-String. "0000000000000000")

1..16|%{...}Überprüfen Sie dann in einer einfachen for-Schleife jede Ziffer, um unser Ausgangsarray aufzubauen, und kehren Sie dann -join''wieder zusammen.

Zurück, 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''

Vorherige, 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 Bytes

Definiert eine anonyme Funktion.

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)

Danke an ETHproductions für die Tipps!

CJam, 62 Bytes

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

Probieren Sie es online aus .

Pyth, 50 Bytes

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

Die Erklärung muss bis zu einem anderen Zeitpunkt warten, ich poste dies auf meinem Handy!

Rubin, 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}

Algorithmus

Drucken Sie einen horizontalen Teiler

Schleife 20 mal (19..0)

Wenn die Schleifennummer nicht durch 5 dividiert wird, konvertieren Sie sie durch Multiplizieren mit 4/5 in eine Zahl im Bereich 16..0. Drucken Sie ein Leerzeichen (ASCII 32) oder #(ASCII 32 + 3 = 35), dem |ein Leerzeichen vorausgeht und auf das ein Leerzeichen folgt.

Wenn die Schleifennummer durch 5 dividiert wird, drucken Sie eine mit der ersten identische | Abschluss-, Zeilenumbruch- und horizontale Teilung.

Perl, 103 Bytes

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

Viele Zeichenfolgenwiederholungen, um ein Raster aus xs zu erstellen, konvertieren die Eingabe in binär und dann s///die xs in #oder $"( ), abhängig von der Markierung an der angegebenen Position ( $x).

PHP, 159 Bytes

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

Verwendung:

php bingrid16.php 4242

Nichts Besonderes, nur das Rendering brutal erzwungen.

Ich habe versucht, einen anderen Winkel mit Arrays anstelle von Schleifen zu verwenden, aber es war länger bei 224 Bytes:

<?=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 Bytes

84 83 Byte Code + -pFlag

-1 Byte nachdem Dom mich daran erinnert hat, eine neue Zeile zu verwenden

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

Probieren Sie es online!

c99 263 bytes

Golf gespielt:

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

ungolfed:

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

Ich wollte nur eine etwas wechselnde Variante präsentieren und fand, dass dies das erste Mal angemessen ist (sogar das kostet mich ein paar Bytes, aber C kann diese Herausforderung in Bytes nicht einmal mit einer Chance ändern, also ist es mir egal), das argc zu verwenden / argv

Rubin, 95

Nicken Sie zu Mhmd für eine prägnante String-Konvertierung, aber ich wollte versuchen, String-Methoden anstelle von Zahlenmethoden zu verwenden.

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

Rubin, 93

Eine etwas kürzere Version, die nur numerische Operationen verwendet.

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

C # 227 Bytes

Golf gespielt:

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

Einrückung:

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

Wenn ich das erste Mal so etwas versuche, wären Tipps willkommen!

Python 3, 145 144 Bytes

In der Reihe:

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

Mit Zeilenumbrüchen:

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 zum Speichern von 1 Byte

Kotlin , 192 Bytes

{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()}

Verschönert

{
    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()
}

Prüfung

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 Bytes

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

Probieren Sie es online!