Dado cualquier entero de 16 bits sin signo, convierta su número de forma decimal (es decir, base 10) en una cuadrícula ASCII 4x4 de sus bits, con el bit más significativo (MSB) en la parte superior izquierda, el bit menos significativo (LSB) en abajo a la derecha, lee a través y luego hacia abajo (como texto en inglés).

Ejemplos

Entrada: 4242

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

Entrada: 33825

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

Requisitos específicos

1. La entrada debe estar en decimal (base-10), sin embargo, puede convertir a binario de la forma que desee (incluido el uso de idiomas integrados, si está disponible).

2. El formato de la tabla de salida debe coincidir exactamente . Esto significa que debe usar los caracteres ASCII específicos ( -, +y |) para las líneas de la cuadrícula de la tabla como se muestra, el interior de cada celda es de 3 caracteres y los bits verdaderos están representados por #mientras que falso está representado por un espacio ( ).

3. Los espacios en blanco iniciales o finales no están permitidos. Se requiere una nueva línea final .

4. El orden de bits debe coincidir con los ejemplos descritos.

Subsidios

1. La entrada debe ser un número de base 10 en la línea de comando, entrada estándar o entrada del usuario, pero no debe estar codificada en su código fuente.

¡Que gane el código más corto más claro ! :-)

J 26 bytes

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

Un verbo anónimo. Afortunadamente, J es muy bueno dibujando cuadros. Probémoslo:

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

Como han mencionado algunos comentaristas, la forma en que J dibuja cuadros depende del sistema: en algunas plataformas, este código funcionará con la configuración predeterminada, pero en otros, los cuadros se dibujarán con caracteres de dibujo de línea Unicode. (Los comandos 9!:6y le9!:7 permiten consultar y configurar los caracteres para dibujar valores en recuadros, respectivamente).

JavaScript (ES6), 102

... o 96 usando en returnlugar de console.log.

Pruebe a ejecutar el fragmento a continuación en un navegador compatible con 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 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-:#^_$>^

Para ejecutar el programa ...

1. Ir al intérprete en línea .
2. Pegue este código en el cuadro de texto grande.
3. Haga clic Show.
4. Ingrese el número deseado en el Inputcuadro.
5. Haga clic Run. (O cambie Slowa algo así como 5 milisegundos y luego haga clic Show).
6. Ta-da!

Salida para 4242:

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

Salida para 33825:

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

Explicación

Oh Dios mío, ¿en qué me he metido? Bueno, aquí va! (El código irrelevante se reemplaza con .s.)

Parte 1: Obtener entrada (almacenar en 0,0) y calcular 32768 (almacenar en 1,0).

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

Parte 2: Imprima "+ --- + --- + --- + ---".

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

Parte 3: Imprima "+" y una nueva línea y verifique si (1,0) es 0 (es decir, hemos terminado). Si es así, termina. De lo contrario, continúe.

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

Parte 4: Obtenga dígitos binarios de entrada, actualizando (0,0) y (1,0) a medida que avanzamos. Imprime las cosas correctas. Aprovecho el comportamiento envolvente de Befunge.

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

Parte 5: Imprima una nueva línea y vuelva a la parte que imprime "+ --- + --- + --- + --- +". Se utiliza un truco envolvente.

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

Sin 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

Pruébalo en línea

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

Gracias a Morgan Thrapp por guardar 4 bytes, y a Jonathan Frech por guardar 5.

Uso

$ 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

gracias por @ w0lf por guardar algunos caracteres.

GNU sed + dc, 116

La puntuación incluye +1 para las -rbanderas para 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/

Prueba de salida:

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

Alternativamente:

Sed puro, 146

Puede pensar que es una trampa usar sedla extensión GNU de '' para evaluar un dccomando. En ese caso, podemos hacer esto un poco diferente, de acuerdo con esta meta-respuesta . Por supuesto, la pregunta establece claramente que la entrada debe estar en la base 10, pero aquí intento afirmar que podemos anular eso para las sedrespuestas y usar unary (base 1) en su lugar.

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

Prueba de salida

Utilizando printfpara generar la cadena unaria necesaria:

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

C ++ 11, 193 191 190 176 172 bytes

Mi primera solución en codegolf, así que no me culpes.

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

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

Versión previa

#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

Pruébelo en línea: Demostración o conjunto de pruebas

Explicación:

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$}/

Definitivamente golfable, pero supongo que es un comienzo. Genera la fila superior, luego, por cada 4 bits, crea una fila par y copia la fila impar anterior.

Pruébalo en línea .

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 gracias al ingenioso 4**8+truco de @ xnor . La impresión principal se realiza en bucle 9 veces, seleccionando la fila adecuada para impar / par.

Pitón 2, 94

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

La idea es tomar el patrón.

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

excepto %sen lugar de espacios en blanco y realizar la sustitución de tuplas. La tupla parece

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

Se crea quitando los dígitos de la entrada en binario y agregando el símbolo correspondiente al frente de la tupla. Una expresión con tupla explícita dio igual longitud.

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

Gracias a Sp3000 por 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''

_{Editar: ahorró 15 bytes al cambiar el orden en que |se dibujan, para que podamos volcarlo .TrimEnd("|")en la salida y, en su lugar, convertir el bucle for en un bloque de subcódigo que produzca una matriz}

_{Edit2: guardó otros 6 bytes al eliminar la necesidad de guardar en la $ovariable y simplemente generar -join''directamente.}

Ooooooooof

Dibujar en PowerShell es difícil . Trabajar con dígitos binarios en PowerShell es difícil .

Utiliza incorporados al [convert]entero de entrada en una representación de cadena en binario, luego se vuelve a emitir a un [int64]modo para que podamos volver a llamar .ToString()para anteponer / rellenar el número apropiado de ceros. (Tenga en cuenta que crear una matriz de cadenas y unirlas @(,"0"*16)-join''es 1 carácter más corto que la cadena literal "0000000000000000")

Luego, realice una simple 1..16|%{...}comprobación de bucle for para cada dígito para construir nuestra matriz de salida, luego finalmente -join''vuelva a unirla.

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

Anterior 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 bytes

Define una función anónima.

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)

¡Gracias a ETHproductions por sus consejos!

CJam, 62 bytes

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

Pruébalo en línea .

Pyth, 50 bytes

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

La explicación tendrá que esperar hasta otro momento, ¡estoy publicando esto en mi teléfono!

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

Algoritmo

Imprimir un divisor horizontal

Loop 20 veces (19..0)

Si el número de bucle no se divide por 5, conviértalo en un número en el rango 16..0 multiplicando por 4/5. Imprima un espacio (ascii 32) o #(ascii 32 + 3 = 35) precedido |y seguido de un espacio.

Si el número de bucle se divide por 5, imprima una | terminación, una nueva línea y un divisor horizontal idéntico al primero.

Perl, 103 bytes

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

Muchas repeticiones de cadenas para hacer una cuadrícula de xs, convertir la entrada a binario y luego s///la xs #ao $"( ) dependiendo del indicador en la posición especificada ( $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";}

Uso:

php bingrid16.php 4242

Nada sofisticado, solo forzó el renderizado.

Intenté otro ángulo usando matrices en lugar de bucles, pero fue más largo en 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 bytes de código + -pbandera

-1 byte después de que Dom me recordó que usara una nueva línea

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

Pruébalo en línea!

c99 263 bytes

golfizado:

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

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

Simplemente me gustó presentar una variante un poco cambiante y sentí que esta es la primera vez que es apropiado (incluso me está costando algunos bytes, pero C no puede este desafío en bytes incluso con una posibilidad, así que no me importa) usar el argumento / argv

Ruby, 95

Asiente con la cabeza a Mhmd para una conversión de cadena concisa, pero quería intentar usar métodos de cadena en lugar de métodos numéricos.

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

Rubí, 93

Una versión ligeramente más corta que usa solo operaciones numéricas.

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

C # 227 bytes

Golfizado:

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

Sangría:

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 primera vez que intento algo como esto, ¡los consejos serán bienvenidos!

Python 3, 145 144 Bytes

En línea:

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

Con nuevas líneas:

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

Editar: Tanques @manatwork para guardar 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()}

Embellecido

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

Prueba

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„# ‡

Pruébalo en línea!