Grade binária de 16 bits

29

Dado qualquer número inteiro de 16 bits não assinado, converta seu número decimal (ou seja, base-10) em uma grade 4x4 ASCII de seus bits, com o bit mais significativo (MSB) na parte superior esquerda, o bit menos significativo (LSB) em canto inferior direito, leia e depois para baixo (como texto em inglês).

Exemplos

Entrada: 4242

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

Entrada: 33825

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

Requisitos Específicos

  1. A entrada deve estar em decimal (base 10), no entanto, você pode converter para binário da maneira que desejar (incluindo o uso de built-ins de idioma, se disponível).

  2. O formato da tabela de saída deve corresponder exatamente . Isto significa que você deve usar os caracteres específicos ASCII ( -, +e |) para as linhas de grade da tabela, como mostrado, interior de cada célula é de 3 caracteres e verdadeiros pedaços são representados por #enquanto falsa é representado por um espaço ( ).

  3. Espaços em branco à esquerda ou à direita não são permitidos. Nova linha final é necessária .

  4. A ordem dos bits deve corresponder aos exemplos, conforme descrito.

Subsídios

  1. A entrada deve ser um número de base 10 na linha de comando, entrada padrão ou entrada do usuário, mas não deve ser codificada em seu código-fonte.

Que ganhe o código mais curto e claro ! :-)

type_outcast
fonte
11
Relacionado
Sp3000 18/09/2015
2
A primeira frase me parece confusa, onde diz "converta sua forma decimal ". Com base no restante da postagem e no exemplo, parece que a entrada é fornecida na forma decimal, mas você precisa converter a forma binária do valor em uma grade.
Reto Koradi 18/09/2015
11
@RetoKoradi você está essencialmente correto, mas a pergunta exige que você converta um número decimal em uma grade binária . Não há um requisito explícito para trabalhar com um número binário, apenas um detalhe de implementação provável.
Type_outcast 18/09/2015
Escrever uma função com o número da base 10 como argumento da função conta como entrada do usuário?
Alex A.
2
Como você diz que o número fornecido é um " número inteiro de 16 bits não assinado ", é por definição em formato binário. Quando li isso pela primeira vez, parecia que a entrada seria dada em forma binária. Tudo fica claro no final. Mas pelo menos para mim, o primeiro parágrafo realmente não captura o problema.
Reto Koradi

Respostas:

21

J, 26 bytes

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

Um verbo anônimo. Felizmente, J é muito bom em desenhar caixas. Vamos tentar:

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

Como alguns comentaristas mencionaram, a maneira como J desenha caixas depende do sistema: em algumas plataformas, esse código funcionará nas configurações padrão, mas em outros, as caixas serão desenhadas usando caracteres de desenho de linha Unicode. (Os comandos 9!:6e9!:7 permitem que você consulta e defina os personagens desenhar valores em caixa, com, respectivamente).

Lynn
fonte
Você (ou qualquer outra pessoa) sabe se existe um consenso no comando de desenho da caixa para a pontuação de golfe? Pessoalmente, acho que a suposição com o código golf é que as soluções funcionam na maioria dos sistemas nos quais o idioma da solução funciona, certo? Como seria uma solução que gera as caixas corretas em todas (ou quase todas) instalações J? Eu realmente gosto da sua solução, a propósito! Meu cérebro ainda está trabalhando, o que é exatamente o que eu gosto no código de golfe.
type_outcast 18/09/2015
5
@type_outcast Não exigimos portabilidade para desafios de golfe com código. Desde que funcione com alguma implementação em uma plataforma, é válido.
Dennis
Obrigado pela resposta @Dennis. Estou feliz porque minha presunção estava incorreta, porque eu ainda gosto da solução de Mauris! :-)
type_outcast 18/09/2015
14

JavaScript (ES6), 102

... ou 96 usando em returnvez de console.log.

Teste a execução do snippet abaixo em um navegador compatível com 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
fonte
6
É "JavaScripy" alguma estranha mashup javascript / python? ;-)
Trauma digital
6
@DigitalTrauma, é claro. Mas como o mundo não está pronto ( tvtropes.org/pmwiki/pmwiki.php/Main/TheWorldIsNotReady ) para esta nova evolução, eu vou reverter para JavaScript
edc65
Legal, isso funciona no Edge!
Arturo Torres Sánchez
Não ... clique ... ... 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 executar o programa ...

  1. Vá para o intérprete online .
  2. Cole esse código na caixa de texto grande.
  3. Clique em Show.
  4. Digite o número desejado na Inputcaixa.
  5. Clique em Run. (Ou mude Slowpara algo como 5 milissegundos e clique em Show.)
  6. Ta-da!

Saída para 4242:

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

Saída para 33825:

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

Explicação

Oh Deus, no que eu me meti? Bem, aqui vai! (Código irrelevante é substituído por .s.)

Parte 1: Obter entrada (armazenar em 0,0) e calcular 32768 (armazenar em 1,0).

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

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

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

Parte 3: Imprima "+" e uma nova linha e verifique se (1,0) é 0 (ou seja, terminamos). Nesse caso, termine. Caso contrário, continue.

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

Parte 4: Obtenha dígitos binários da entrada, atualizando (0,0) e (1,0) à medida que avançamos. Imprima as coisas certas. Aproveito o comportamento envolvente de Befunge.

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

Parte 5: imprima uma nova linha e volte à parte que imprime "+ --- + --- + --- + --- +". O truque de enrolar é usado.

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

Ta-da!

El'endia Starman
fonte
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))

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

Experimente online

Alex A.
fonte
10

Python 2, 157 153 151 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+'+'

Agradecemos a Morgan Thrapp por salvar 4 bytes e a Jonathan Frech por salvar 5.

Uso

$ python test.py
33825
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
Zach Gates
fonte
Você pode salvar dois bytes se você puxar '+---'*4em uma variável e mais dois, se você fizerj=''.join
Morgan Thrapp
Sem problemas! Na verdade, eu estava trabalhando em uma solução muito semelhante.
Morgan Thrapp 18/09/2015
@ downvoter Gostaria de explicar?
Zach Gates
Desde que você não use Python 3, você pode substituir int(input())com input()e salvar cinco bytes.
Jonathan Frech 10/09
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

obrigado por @ w0lf por salvar alguns caracteres.

Mhmd
fonte
11
Você pode salvar alguns bytes se escrever caracteres literais usando a ?notação (ex: em ?|vez de '|'). Isso funciona para tudo, exceto o espaço.
Cristian Lupascu 19/09/2015
@ w0lf Descobri que ?\sfunciona para o espaço, mas não é realmente útil aqui.
Mhmd
7

GNU sed + dc, 116

A pontuação inclui +1 para -rsinalizadores 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/

Saída de teste:

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

Alternativamente:

Sed puro, 146

Você pode pensar que é trapaça usar seda extensão GNU para avaliar um dccomando. Nesse caso, podemos fazer isso de maneira um pouco diferente, de acordo com esta meta-resposta . É claro que a pergunta afirma claramente que a entrada deve estar na base 10, mas aqui estou tentando afirmar que podemos substituir isso por sedrespostas e usar unário (base 1).

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

Saída de teste

Usando printfpara gerar a sequência unária necessária:

$ printf "%33825s" | tr ' ' 1 | sed -rf 16bitgrid.sed 
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
$ 
Trauma Digital
fonte
Agradável. Isso parece um pouco com a solução Perl que eu criei como uma prova de conceito (privada) enquanto ajusta a pergunta.
Type_outcast 18/09/2015
@type_outcast BTW, está perfeitamente correto postar sua própria solução como resposta :) #
Digital Trauma
Eu sei :-) Eu não gastei muito tempo jogando golfe, pois estava mais focado em fazer uma boa pergunta, mas ainda posso revisitá-la e publicá-la se puder jogar em algo pelo menos respeitável. No momento, eu estou me divertindo muito gritando as respostas de todos os outros.
Type
6

C ++ 11, 193 191 190 176 172 bytes

Minha primeira solução em codegolf já, então não me culpe.

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

Versão anterior

#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
fonte
Dica: 0x10000 é 65536, com o prefixo '0x', o hex é sempre maior que o decimal
edc65
Dica 2: você deve evitar using namespace stdno código de produção. E não é útil aqui também.
Edc65 18/09/2015
@ edc65 dec-> hex boa ideia, eu sempre pensei em hex ter uma representação mais curta, mas esqueça 0x. using namespace stdeconomiza alguns bytes, porque não preciso prefixar coute cincom std::. Mesmo usando apenas using std::cout;não vai ajudar.
Zereges 18/09/2015
Hey Zereges. Você pode remover o espaço entre a inclusão e a biblioteca .. e remover o tipo de retorno para a função principal.
Wendelbsilva 18/09/2015
C++não suporta int automático.
Zereges 18/09/2015
6

Pitão, 37 bytes

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

Experimente on-line: Demonstration or Test Suite

Explicação:

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
fonte
5

CJam, 43 41 bytes

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

Definitivamente jogável, mas acho que é um começo. Gera a linha superior e, a cada 4 bits, cria uma linha par e copia a linha ímpar anterior.

Experimente online .

Sp3000
fonte
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 graças ao puro 4**8+truque de @ xnor . A impressão principal é feita repetindo 9 vezes, selecionando a linha apropriada para ímpar / par.

Sp3000
fonte
Eu acho que bin(4**8+input())[3:]economiza mais de um byteformat
xnor
@xnor Oh, isso é puro :)
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

A ideia é seguir o padrão

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

exceto %sno lugar de espaços em branco e faça a substituição da tupla. A tupla parece

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

Ele é criado retirando os dígitos da entrada em binário e adicionando o símbolo correspondente à frente da tupla. Uma expressão com tupla explícita deu o mesmo comprimento.

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

Obrigado ao Sp3000 por 2 bytes.

xnor
fonte
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 - salvou 15 bytes alterando a ordem que |é desenhada, para que possamos despejar .TrimEnd("|")a saída e converter o loop for em um bloco de subcódigo que produz uma matriz

Edit2 - salvou outros 6 bytes, eliminando a necessidade de salvar na $ovariável e apenas enviando -join''diretamente.

Ooooooooof.

Desenhar no PowerShell é difícil . Trabalhar com dígitos binários no PowerShell é difícil .

Usa built-ins para [convert]o número inteiro de entrada em uma representação de string em binário e, em seguida, converte novamente em um [int64]para que possamos chamar novamente .ToString(), a fim de acrescentar / preencher o número apropriado de zeros. (Observe que a criação de uma matriz de cadeias e a união delas @(,"0"*16)-join''é 1 caractere menor que a cadeia literal "0000000000000000")

Em seguida, faça um loop for simples 1..16|%{...}verificando cada dígito para criar nossa matriz de saída e, finalmente, -join''juntos novamente.


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
fonte
11
Espero que tenha sido um "divertido duro". :-) +1 para sua explicação; ajudou meu entendimento limitado do PowerShell.
type_outcast
3

Javascript (ES6), 216 207 bytes

Define uma função 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)

Obrigado a ETHproductions por dicas!

adroitwhiz
fonte
Bom trabalho! Como você usa o ES6, eis algumas dicas: 1. Sempre que você precisar usar uma string como único parâmetro da função, poderá usar uma string de modelo, assim: .join` | `​2. Você também pode usar strings de modelo para interpolar valores: i=>`,${"0".repeat....join`,`},`.replace...3 Você pode encontrar mais dicas do ES6 neste tópico .
ETHproductions
Isso parece ter parado de funcionar, mas, ao jogar um pouco mais, posso obter 197 com o resultado correto: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
Mantendo a sua lógica exata, isso pode ser golfed a 169, consulte jsfiddle.net/76fp7aw6
edc65
2

CJam, 62 bytes

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

Experimente online .

Andrea Biondo
fonte
2

Pitão, 50 bytes

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

Explicação terá que esperar até outra hora, eu estou postando isso no meu telefone!

Sok
fonte
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 um divisor horizontal

Loop 20 vezes (19..0)

Se o número do loop não for dividido por 5, converta para um número no intervalo 16..0 multiplicando por 4/5. Imprima um espaço (ascii 32) ou #(ascii 32 + 3 = 35) precedido |e seguido por um espaço.

Se o número do loop for dividido por 5, imprima | |, nova linha e um divisor horizontal idêntico ao primeiro.

Level River St
fonte
2

Perl, 103 bytes

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

Muita repetição corda para fazer uma grade de xs, converter a entrada para binários e, em seguida, s///os xs de #ou $"( ), dependendo da bandeira na posição especificada ( $x).

Dom Hastings
fonte
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 extravagante, apenas forçado com força a renderização.

Tentei outro ângulo usando matrizes em vez de loops, mas era mais longo em 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
fonte
2

Perl 5 , 85 84 bytes

84 83 bytes de código + -psinalizador

-1 byte depois que Dom me lembrou de usar uma nova linha

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

Experimente online!

Xcali
fonte
Boa abordagem, muito melhor do que a minha! Uma nova linha literal também poupará um byte extra $/!
Dom Hastings
1

c99 263 bytes

golfed:

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

Eu apenas gostei de apresentar uma variante um pouco instável e senti que esta é a primeira vez que é apropriada (até me custando alguns bytes, mas C não pode desafiar esses bytes, mesmo com uma chance, então eu não me importo) de usar o argc / argv

Zaibis
fonte
1

Ruby, 95

Acene para Mhmd para uma conversão de String concisa, mas eu queria tentar usar métodos de string em vez de métodos numéricos.

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

Ruby, 93

Uma versão um pouco mais curta usando apenas operações numéricas.

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

C # 227 bytes

Golfe:

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

Indenção:

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

Na primeira vez que estou tentando algo assim, dicas serão bem-vindas!

anthonytimmers
fonte
Em primeiro lugar, conto 286 bytes e você pode remover os espaços de indentação.
Blue
Como exatamente você conta isso? Estive nas propriedades para ver o tamanho do arquivo, mas não tenho certeza se é esse o caminho! Sem recuo, reduzi-me a 230 bytes!
Anthonytimmers
Use algo como mothereff.in/byte-counter , ou se você estiver no linux, use o wccomando
Blue
1

Python 3, 145 144 bytes

Na linha:

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

Com novas linhas:

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 para economizar 1 byte

Bassintag
fonte
11
Com base em gnibbler da ponta , hardcode r=0,1,2,3é um carácter mais curto do que gerando-o com 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()}

Embelezado

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

Teste

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
fonte