Cuadrícula binaria de 16 bits

29

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

type_outcast
fuente
1
Relacionado
Sp3000
2
La primera oración me suena confusa, donde dice "convertir su forma decimal ". Según el resto de la publicación y el ejemplo, parece que la entrada se da en forma decimal, pero debe convertir la forma binaria del valor en una cuadrícula.
Reto Koradi
1
@RetoKoradi tiene razón, pero la pregunta requiere que convierta un número decimal en una cuadrícula binaria . No existe un requisito explícito para trabajar con un número binario, solo un posible detalle de implementación.
type_outcast
¿Escribir una función con el número base 10 como argumento de la función cuenta como entrada del usuario?
Alex A.
2
Como usted dice que el número dado es un "entero de 16 bits sin signo", es, por definición, en forma binaria. Cuando leí esto por primera vez, en realidad parecía que la entrada se daría en forma binaria. Todo queda claro hacia el final. Pero al menos para mí, el primer párrafo realmente no capta el problema en absoluto.
Reto Koradi

Respuestas:

21

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

Lynn
fuente
¿Sabe usted (o alguien más) si hay un consenso sobre el comando de dibujo de cuadro para la puntuación de golf, entonces? Personalmente, creo que la suposición con Code Golf es que las soluciones funcionan en la mayoría de los sistemas en los que se ejecuta el lenguaje de la solución, ¿verdad? ¿Cómo se vería una solución que genera los cuadros correctos en todas (o casi todas) las instalaciones de J? Realmente me gusta tu solución, por cierto! Mi cerebro todavía está trabajando, que es exactamente lo que me gusta del golf de código.
type_outcast
55
@type_outcast No requerimos portabilidad para los desafíos de golf de código. Siempre que funcione con alguna implementación en una plataforma, es válida.
Dennis
Gracias por la respuesta @Dennis. ¡Estoy feliz de que mi presunción fuera incorrecta, entonces, porque (todavía) realmente me gusta la solución de Mauris! :-)
type_outcast
14

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>

edc65
fuente
66
¿Es "JavaScripy" un extraño mashup de javascript / python? ;-)
Digital Trauma
66
@DigitalTrauma, por supuesto. Pero como el mundo no está listo ( tvtropes.org/pmwiki/pmwiki.php/Main/TheWorldIsNotReady ) para esta nueva evolución, volveré a JavaScript
edc65
¡Genial, esto funciona en Edge!
Arturo Torres Sánchez
Debe ... no ... hacer clic ... tvtropes ...
RK.
14

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!

El'endia Starman
fuente
10

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

Alex A.
fuente
10

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
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
Puertas de Zach
fuente
Puede guardar dos bytes si ingresa '+---'*4a una variable y dos más si lo hacej=''.join
Morgan Thrapp
¡No hay problema! En realidad estaba trabajando en una solución muy similar.
Morgan Thrapp
@downvoter ¿Cuidado de explicar?
Zach Gates
Puesto que usted no usa Python 3, se puede reemplazar int(input())con input()y guardar cinco bytes.
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

gracias por @ w0lf por guardar algunos caracteres.

Mhmd
fuente
1
Puede guardar algunos bytes si escribe caracteres literales usando la ?notación (ej .: en ?|lugar de '|'). Esto funciona para todo excepto el espacio.
Cristian Lupascu
@ w0lf He encontrado que ?\sfunciona para el espacio, sin embargo, no es realmente útil aquí.
Mhmd
7

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 
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
$ 
Trauma digital
fuente
Buena esa. Esto se parece un poco a la solución de Perl que se me ocurrió como prueba de concepto (privada) al ajustar la pregunta.
type_outcast
@type_outcast Por cierto, está perfectamente bien publicar su propia solución como respuesta :)
Digital Trauma
Lo sé :-) No pasé mucho tiempo jugando al golf, ya que estaba más concentrado en hacer una buena pregunta, pero aún puedo volver a visitarlo y publicarlo si puedo convertirlo en algo respetable al menos hasta la mitad. En este momento me estoy divirtiendo demasiado escuchando las respuestas de todos los demás.
type_outcast
6

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");
    }
}
Zereges
fuente
Sugerencia: 0x10000 es 65536, con el prefijo '0x', el hexadecimal siempre es más largo que el decimal
edc65
Sugerencia 2: debe evitar using namespace stden el código de producción. Y tampoco es útil aquí.
edc65
@ edc65 dec-> hex buena idea, siempre pensé que el hex tiene una representación más corta, pero olvídate 0x. using namespace stdahorra algunos bytes, porque no tengo que prefijar couty cincon std::. Incluso usando simplemente using std::cout;no ayudará.
Zereges
Hola Zereges Puede eliminar el espacio entre la inclusión y la biblioteca ... y eliminar el tipo de retorno para la función principal.
wendelbsilva
C++no es compatible con auto int.
Zereges
6

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
Jakube
fuente
5

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 .

Sp3000
fuente
4

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.

Sp3000
fuente
Creo que eso bin(4**8+input())[3:]ahorra un byteformat
xnor
@xnor Oh, eso está bien :)
Sp3000
4

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.

xnor
fuente
4

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('|')
AdmBorkBork
fuente
1
Espero que haya sido un "divertido duro". :-) +1 para su explicación; ayudó a mi comprensión limitada de PowerShell.
type_outcast
3

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!

adroitwhiz
fuente
¡Buen trabajo! Dado que está utilizando ES6, aquí hay algunos consejos: 1. Cada vez que necesite usar una cadena como el único parámetro de una función, puede usar una cadena de plantilla, así: .join` | `​2. También puede usar cadenas de plantilla para interpolar valores: i=>`,${"0".repeat....join`,`},`.replace...3 Puede encontrar más consejos de ES6 en este hilo .
ETHproductions
Esto parece haber dejado de funcionar, pero al jugar un poco más, puedo obtener 197 con el resultado correcto: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
Manteniendo su lógica exacta, esto puede ser golfizado a 169, ver jsfiddle.net/76fp7aw6
edc65
2

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!

Sok
fuente
2

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.

Level River St
fuente
2

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

Dom Hastings
fuente
2

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

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!

Xcali
fuente
Agradable, mucho mejor enfoque que el mío! ¡Una nueva línea literal también le ahorrará un byte adicional $/!
Dom Hastings
1

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

Zaibis
fuente
1

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}}
No es que Charles
fuente
1

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}
No es que Charles
fuente
1

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!

anthonytimmers
fuente
En primer lugar, cuento 286 bytes y puedes eliminar los espacios de sangría.
Azul
¿Cómo lo cuentas exactamente? He estado yendo a las propiedades para ver el tamaño del archivo allí, ¡pero no estoy seguro de si esa es la forma de hacerlo! ¡Sin sangrado, he reducido a 230 bytes!
anthonytimmers
Use algo como mothereff.in/byte-counter , o si está en Linux, use el wccomando
Azul
1

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

Bassintag
fuente
1
Basado en gnibbler 's punta , hardcoding r=0,1,2,3es 1 carácter más corta que la generación de con r=range(4).
manatwork
0

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)
}
jrtapsell
fuente